passenger 4.0.60 → 5.0.0.beta1

data/ext/common/agents/HelperAgent/SystemMetricsTool.cpp

@@ -31,29 +31,29 @@
 #include <Utils/StrIntUtils.h>
 #include <Utils/SystemMetricsCollector.h>
 
-namespace SystemMetricsTool {
-
 using namespace std;
 using namespace Passenger;
 
-struct Options {
-	bool xml;
-	SystemMetrics::XmlOptions xmlOptions;
-	SystemMetrics::DescriptionOptions descOptions;
-	int interval;
-	bool useStdin;
-	bool exitOnUnexpectedError;
-	bool help;
+namespace {
+	struct Options {
+		bool xml;
+		SystemMetrics::XmlOptions xmlOptions;
+		SystemMetrics::DescriptionOptions descOptions;
+		int interval;
+		bool useStdin;
+		bool exitOnUnexpectedError;
+		bool help;
 
-	Options() {
-		xml = false;
-		descOptions.colors = isatty(1);
-		interval = -1;
-		useStdin = false;
-		exitOnUnexpectedError = true;
-		help = false;
-	}
-};
+		Options() {
+			xml = false;
+			descOptions.colors = isatty(1);
+			interval = -1;
+			useStdin = false;
+			exitOnUnexpectedError = true;
+			help = false;
+		}
+	};
+}
 
 static bool
 isFlag(const char *arg, char shortFlagName, const char *longFlagName) {
@@ -163,8 +163,8 @@ perform(const Options &options, SystemMetricsCollector &collector, SystemMetrics
 	}
 }
 
-static int
-main(int argc, char *argv[]) {
+int
+systemMetricsMain(int argc, char *argv[]) {
 	Options options = parseOptions(argc, argv);
 	if (options.help) {
 		usage();
@@ -195,5 +195,3 @@ main(int argc, char *argv[]) {
 	}
 	return 0;
 }
-
-} // namespace SystemMetricsTool

data/ext/common/agents/LoggingAgent/AdminServer.h

@@ -0,0 +1,369 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013-2014 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_LOGGING_AGENT_ADMIN_SERVER_H_
+#define _PASSENGER_LOGGING_AGENT_ADMIN_SERVER_H_
+
+#include <sstream>
+#include <string>
+
+#include <agents/LoggingAgent/LoggingServer.h>
+#include <ServerKit/HttpServer.h>
+#include <DataStructures/LString.h>
+#include <Exceptions.h>
+#include <StaticString.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/modp_b64.h>
+#include <Utils/json.h>
+
+namespace Passenger {
+namespace LoggingAgent {
+
+using namespace std;
+
+
+class Request: public ServerKit::BaseHttpRequest {
+public:
+	string body;
+	Json::Value jsonBody;
+
+	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Request);
+};
+
+class AdminServer: public ServerKit::HttpServer<AdminServer, ServerKit::HttpClient<Request> > {
+public:
+	enum PrivilegeLevel {
+		NONE,
+		READONLY,
+		FULL
+	};
+
+	struct Authorization {
+		PrivilegeLevel level;
+		string username;
+		string password;
+	};
+
+private:
+	typedef ServerKit::HttpServer<AdminServer, ServerKit::HttpClient<Request> > ParentClass;
+	typedef ServerKit::HttpClient<Request> Client;
+	typedef ServerKit::HeaderTable HeaderTable;
+
+	bool parseAuthorizationHeader(Request *req, string &username,
+		string &password) const
+	{
+		const LString *auth = req->headers.lookup("authorization");
+
+		if (auth == NULL || auth->size <= 6 || !psg_lstr_cmp(auth, "Basic ", 6)) {
+			return false;
+		}
+
+		auth = psg_lstr_make_contiguous(auth, req->pool);
+		string authData = modp::b64_decode(
+			auth->start->data + sizeof("Basic ") - 1,
+			auth->size - (sizeof("Basic ") - 1));
+		string::size_type pos = authData.find(':');
+		if (pos == string::npos) {
+			return false;
+		}
+
+		username = authData.substr(0, pos);
+		password = authData.substr(pos + 1);
+		return true;
+	}
+
+	const Authorization *lookupAuthorizationRecord(const StaticString &username) const {
+		vector<Authorization>::const_iterator it, end = authorizations.end();
+
+		for (it = authorizations.begin(); it != end; it++) {
+			if (it->username == username) {
+				return &(*it);
+			}
+		}
+
+		return NULL;
+	}
+
+	bool authorize(Client *client, Request *req, PrivilegeLevel level) const {
+		if (authorizations.empty()) {
+			return true;
+		}
+
+		string username, password;
+		if (!parseAuthorizationHeader(req, username, password)) {
+			return false;
+		}
+
+		const Authorization *auth = lookupAuthorizationRecord(username);
+		return auth != NULL
+			&& auth->level >= level
+			&& constantTimeCompare(password, auth->password);
+	}
+
+	void processPing(Client *client, Request *req) {
+		if (authorize(client, req, READONLY)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+			headers.insert(req->pool, "content-type", "application/json");
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void processShutdown(Client *client, Request *req) {
+		if (req->method != HTTP_POST) {
+			respondWith405(client, req);
+		} else if (authorize(client, req, FULL)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "content-type", "application/json");
+			exitEvent->notify();
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void processConfig(Client *client, Request *req) {
+		if (req->method == HTTP_GET) {
+			if (!authorize(client, req, READONLY)) {
+				respondWith401(client, req);
+			}
+
+			HeaderTable headers;
+			Json::Value doc;
+
+			headers.insert(req->pool, "content-type", "application/json");
+			doc["log_level"] = getLogLevel();
+
+			writeSimpleResponse(client, 200, &headers, doc.toStyledString());
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else if (req->method == HTTP_PUT) {
+			if (!authorize(client, req, FULL)) {
+				respondWith401(client, req);
+			} else if (!req->hasBody()) {
+				endAsBadRequest(&client, &req, "Body required");
+			}
+			// Continue in processConfigBody()
+		} else {
+			respondWith405(client, req);
+		}
+	}
+
+	void processConfigBody(Client *client, Request *req) {
+		HeaderTable headers;
+		Json::Value &json = req->jsonBody;
+
+		headers.insert(req->pool, "content-type", "application/json");
+
+		if (json.isMember("log_level")) {
+			setLogLevel(json["log_level"].asInt());
+		}
+		if (json.isMember("log_file")) {
+			if (!setLogFile(json["log_file"].asCString())) {
+				int e = errno;
+				unsigned int bufsize = 1024;
+				char *message = (char *) psg_pnalloc(req->pool, bufsize);
+				snprintf(message, bufsize, "{ \"status\": \"error\", "
+					"\"message\": \"Cannot open log file: %s (errno=%d)\" }",
+					strerror(e), e);
+				writeSimpleResponse(client, 500, &headers, message);
+				if (!req->ended()) {
+					endRequest(&client, &req);
+				}
+				return;
+			}
+			P_NOTICE("Log file opened.");
+		}
+
+		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void processReopenLogs(Client *client, Request *req) {
+		if (req->method != HTTP_POST) {
+			respondWith405(client, req);
+		} else if (authorize(client, req, FULL)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "content-type", "application/json");
+
+			string logFile = getLogFile();
+			if (logFile.empty()) {
+				writeSimpleResponse(client, 500, &headers, "{ \"status\": \"error\", "
+					"\"code\": \"NO_LOG_FILE\", "
+					"\"message\": \"" PROGRAM_NAME " was not configured with a log file.\" }\n");
+			} else {
+				if (!setLogFile(logFile.c_str())) {
+					int e = errno;
+					unsigned int bufsize = 1024;
+					char *message = (char *) psg_pnalloc(req->pool, bufsize);
+					snprintf(message, bufsize, "{ \"status\": \"error\", "
+						"\"code\": \"LOG_FILE_OPEN_ERROR\", "
+						"\"message\": \"Cannot reopen log file: %s (errno=%d)\" }",
+						strerror(e), e);
+					writeSimpleResponse(client, 500, &headers, message);
+					if (!req->ended()) {
+						endRequest(&client, &req);
+					}
+					return;
+				}
+				P_NOTICE("Log file reopened.");
+				writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
+			}
+
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void respondWith401(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		headers.insert(req->pool, "www-authenticate", "Basic realm=\"admin\"");
+		writeSimpleResponse(client, 401, &headers, "Unauthorized");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith404(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		writeSimpleResponse(client, 404, &headers, "Not found");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith405(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		writeSimpleResponse(client, 405, &headers, "Method not allowed");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith422(Client *client, Request *req, const StaticString &body) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		headers.insert(req->pool, "content-type", "text/plain; charset=utf-8");
+		writeSimpleResponse(client, 422, &headers, body);
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+protected:
+	virtual void onRequestBegin(Client *client, Request *req) {
+		const StaticString path(req->path.start->data, req->path.size);
+
+		P_INFO("Admin request: " << path);
+
+		if (path == P_STATIC_STRING("/ping.json")) {
+			processPing(client, req);
+		} else if (path == P_STATIC_STRING("/shutdown.json")) {
+			processShutdown(client, req);
+		} else if (path == P_STATIC_STRING("/config.json")) {
+			processConfig(client, req);
+		} else if (path == P_STATIC_STRING("/reopen_logs.json")) {
+				processReopenLogs(client, req);
+		} else {
+			respondWith404(client, req);
+		}
+	}
+
+	virtual ServerKit::Channel::Result onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode)
+	{
+		if (buffer.size() > 0) {
+			// Data
+			req->body.append(buffer.start, buffer.size());
+		} else if (errcode == 0) {
+			// EOF
+			Json::Reader reader;
+			if (reader.parse(req->body, req->jsonBody)) {
+				processConfigBody(client, req);
+			} else {
+				respondWith422(client, req, reader.getFormattedErrorMessages());
+			}
+		} else {
+			// Error
+			disconnect(&client);
+		}
+		return ServerKit::Channel::Result(buffer.size(), false);
+	}
+
+	virtual void deinitializeRequest(Client *client, Request *req) {
+		req->body.clear();
+		if (!req->jsonBody.isNull()) {
+			req->jsonBody = Json::Value();
+		}
+		ParentClass::deinitializeRequest(client, req);
+	}
+
+public:
+	LoggingServer *loggingServer;
+	EventFd *exitEvent;
+	vector<Authorization> authorizations;
+
+	AdminServer(ServerKit::Context *context)
+		: ParentClass(context),
+		  loggingServer(NULL),
+		  exitEvent(NULL)
+		{ }
+
+	virtual StaticString getServerName() const {
+		return P_STATIC_STRING("LoggerAdminServer");
+	}
+
+	static PrivilegeLevel parseLevel(const StaticString &level) {
+		if (level == "readonly") {
+			return READONLY;
+		} else if (level == "full") {
+			return FULL;
+		} else {
+			throw RuntimeException("Invalid privilege level " + level);
+		}
+	}
+};
+
+
+} // namespace LoggingAgent
+} // namespace Passenger
+
+#endif /* _PASSENGER_LOGGING_AGENT_ADMIN_SERVER_H_ */

data/ext/common/agents/LoggingAgent/LoggingServer.h

@@ -38,6 +38,7 @@
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <grp.h>
+#include <dirent.h>
 #include <cstring>
 #include <ctime>
 #include <cassert>

data/ext/common/agents/LoggingAgent/Main.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -34,69 +34,84 @@
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
+#include <algorithm>
 #include <stdlib.h>
 #include <signal.h>
 
 #include <agents/Base.h>
+#include <agents/LoggingAgent/OptionParser.h>
 #include <agents/LoggingAgent/LoggingServer.h>
-#include <agents/LoggingAgent/AdminController.h>
+#include <agents/LoggingAgent/AdminServer.h>
 
 #include <AccountsDatabase.h>
 #include <Account.h>
 #include <Exceptions.h>
+#include <FileDescriptor.h>
+#include <BackgroundEventLoop.h>
 #include <ResourceLocator.h>
 #include <MessageServer.h>
+#include <Constants.h>
 #include <Utils.h>
 #include <Utils/IOUtils.h>
+#include <Utils/StrIntUtils.h>
 #include <Utils/MessageIO.h>
-#include <Utils/Base64.h>
 #include <Utils/VariantMap.h>
 
 using namespace oxt;
 using namespace Passenger;
 
 
-/***** Agent options *****/
-
-static VariantMap agentsOptions;
-static string passengerRoot;
-static string socketAddress;
-static string adminSocketAddress;
-static string password;
-static string username;
-static string groupname;
-static string adminToolStatusPassword;
-
 /***** Constants and working objects *****/
 
-static const int MESSAGE_SERVER_THREAD_STACK_SIZE = 128 * 1024;
-
-struct WorkingObjects {
-	ResourceLocatorPtr resourceLocator;
-	FileDescriptor serverSocketFd;
-	AccountsDatabasePtr adminAccountsDatabase;
-	MessageServerPtr adminServer;
-	boost::shared_ptr<oxt::thread> adminServerThread;
-	AccountsDatabasePtr accountsDatabase;
-	LoggingServerPtr loggingServer;
-
-	~WorkingObjects() {
-		// Stop thread before destroying anything else.
-		if (adminServerThread != NULL) {
-			adminServerThread->interrupt_and_join();
-		}
-	}
-};
-
-static struct ev_loop *eventLoop = NULL;
-static LoggingServer *loggingServer = NULL;
-static int exitCode = 0;
+namespace Passenger {
+namespace LoggingAgent {
+	struct WorkingObjects {
+		string password;
+		FileDescriptor serverSocketFd;
+		vector<int> adminSockets;
+		vector<LoggingAgent::AdminServer::Authorization> adminAuthorizations;
+
+		ResourceLocator *resourceLocator;
+		BackgroundEventLoop *bgloop;
+		ServerKit::Context *serverKitContext;
+		AccountsDatabasePtr accountsDatabase;
+		LoggingServer *loggingServer;
+
+		LoggingAgent::AdminServer *adminServer;
+		EventFd exitEvent;
+		EventFd allClientsDisconnectedEvent;
+
+		struct ev_signal sigintWatcher;
+		struct ev_signal sigtermWatcher;
+		struct ev_signal sigquitWatcher;
+		unsigned int terminationCount;
+
+		WorkingObjects()
+			: resourceLocator(NULL),
+			  bgloop(NULL),
+			  serverKitContext(NULL),
+			  loggingServer(NULL),
+			  terminationCount(0)
+			{ }
+	};
+} // namespace LoggingAgent
+} // namespace Passenger
+
+using namespace Passenger::LoggingAgent;
+
+static VariantMap *agentsOptions;
+static WorkingObjects *workingObjects;
 
 
 /***** Functions *****/
 
+static void printInfo(EV_P_ struct ev_signal *watcher, int revents);
+static void onTerminationSignal(EV_P_ struct ev_signal *watcher, int revents);
+static void adminServerShutdownFinished(LoggingAgent::AdminServer *server);
+static void waitForExitEvent();
+
 void
-feedbackFdBecameReadable(ev::io &watcher, int revents) {
+loggingAgentFeedbackFdBecameReadable(ev::io &watcher, int revents) {
 	/* This event indicates that the watchdog has been killed.
 	 * In this case we'll kill all descendant
 	 * processes and exit. There's no point in keeping this agent
@@ -110,29 +125,6 @@ feedbackFdBecameReadable(ev::io &watcher, int revents) {
 	_exit(2); // In case killpg() fails.
 }
 
-static string
-myself() {
-	struct passwd *entry = getpwuid(geteuid());
-	if (entry != NULL) {
-		return entry->pw_name;
-	} else {
-		throw NonExistentUserException(string("The current user, UID ") +
-			toString(geteuid()) + ", doesn't have a corresponding " +
-			"entry in the system's user database. Please fix your " +
-			"system's user database first.");
-	}
-}
-
-static void
-initializeBareEssentials(int argc, char *argv[]) {
-	agentsOptions = initializeAgent(argc, argv, "PassengerLoggingAgent");
-	curl_global_init(CURL_GLOBAL_ALL);
-	if (agentsOptions.get("test_binary", false) == "1") {
-		printf("PASS\n");
-		exit(0);
-	}
-}
-
 static string
 findUnionStationGatewayCert(const ResourceLocator &locator,
 	const string &cert)
@@ -147,204 +139,419 @@ findUnionStationGatewayCert(const ResourceLocator &locator,
 }
 
 static void
-initializeOptions(WorkingObjects &wo) {
-	passengerRoot      = agentsOptions.get("passenger_root");
-	socketAddress      = agentsOptions.get("logging_agent_address");
-	adminSocketAddress = agentsOptions.get("logging_agent_admin_address");
-	password           = agentsOptions.get("logging_agent_password");
-	username           = agentsOptions.get("analytics_log_user", false, myself());
-	groupname          = agentsOptions.get("analytics_log_group", false);
-	adminToolStatusPassword = agentsOptions.get("admin_tool_status_password");
-
-	wo.resourceLocator = boost::make_shared<ResourceLocator>(passengerRoot);
-	agentsOptions.set("union_station_gateway_cert", findUnionStationGatewayCert(
-		*wo.resourceLocator, agentsOptions.get("union_station_gateway_cert", false)));
+makeFileWorldReadableAndWritable(const string &path) {
+	int ret;
+
+	do {
+		ret = chmod(path.c_str(), parseModeString("u=rw,g=rw,o=rw"));
+	} while (ret == -1 && errno == EINTR);
 }
 
 static void
-initializePrivilegedWorkingObjects(WorkingObjects &wo) {
-	wo.serverSocketFd = createServer(socketAddress.c_str());
-	if (getSocketAddressType(socketAddress) == SAT_UNIX) {
-		int ret;
-
-		do {
-			ret = chmod(parseUnixSocketAddress(socketAddress).c_str(),
-				S_ISVTX |
-				S_IRUSR | S_IWUSR | S_IXUSR |
-				S_IRGRP | S_IWGRP | S_IXGRP |
-				S_IROTH | S_IWOTH | S_IXOTH);
-		} while (ret == -1 && errno == EINTR);
+parseAndAddAdminAuthorization(const string &description) {
+	TRACE_POINT();
+	WorkingObjects *wo = workingObjects;
+	LoggingAgent::AdminServer::Authorization auth;
+	vector<string> args;
+
+	split(description, ':', args);
+
+	if (args.size() == 2) {
+		auth.level = LoggingAgent::AdminServer::FULL;
+		auth.username = args[0];
+		auth.password = strip(readAll(args[1]));
+	} else if (args.size() == 3) {
+		auth.level = LoggingAgent::AdminServer::parseLevel(args[0]);
+		auth.username = args[1];
+		auth.password = strip(readAll(args[2]));
+	} else {
+		P_BUG("Too many elements in authorization description");
 	}
 
-	wo.adminAccountsDatabase = boost::make_shared<AccountsDatabase>();
-	wo.adminAccountsDatabase->add("_passenger-status", adminToolStatusPassword, false);
-	wo.adminServer = boost::make_shared<MessageServer>(parseUnixSocketAddress(adminSocketAddress),
-		wo.adminAccountsDatabase);
+	wo->adminAuthorizations.push_back(auth);
 }
 
 static void
-lowerPrivilege(const string &username, const struct passwd *user, gid_t gid) {
-	int e;
-
-	if (initgroups(username.c_str(), gid) != 0) {
-		e = errno;
-		P_WARN("WARNING: Unable to set supplementary groups for " <<
-			"PassengerLoggingAgent: " << strerror(e) << " (" << e << ")");
+initializePrivilegedWorkingObjects() {
+	TRACE_POINT();
+	const VariantMap &options = *agentsOptions;
+	WorkingObjects *wo = workingObjects = new WorkingObjects();
+
+	wo->password = options.get("logging_agent_password", false);
+	if (wo->password.empty()) {
+		wo->password = strip(readAll(options.get("logging_agent_password_file")));
 	}
-	if (setgid(gid) != 0) {
-		e = errno;
-		P_WARN("WARNING: Unable to lower PassengerLoggingAgent's "
-			"privilege to that of user '" << username <<
-			"': cannot set group ID to " << gid <<
-			": " << strerror(e) <<
-			" (" << e << ")");
+
+	vector<string> authorizations = options.getStrSet("logging_agent_authorizations",
+		false);
+	string description;
+
+	UPDATE_TRACE_POINT();
+	foreach (description, authorizations) {
+		parseAndAddAdminAuthorization(description);
 	}
-	if (setuid(user->pw_uid) != 0) {
-		e = errno;
-		P_WARN("WARNING: Unable to lower PassengerLoggingAgent's "
-			"privilege to that of user '" << username <<
-			"': cannot set user ID: " << strerror(e) <<
-			" (" << e << ")");
+}
+
+static void
+startListening() {
+	TRACE_POINT();
+	const VariantMap &options = *agentsOptions;
+	WorkingObjects *wo = workingObjects;
+	string address;
+	vector<string> adminAddresses;
+
+	address = options.get("logging_agent_address");
+	wo->serverSocketFd = createServer(address.c_str());
+	if (getSocketAddressType(address) == SAT_UNIX) {
+		makeFileWorldReadableAndWritable(parseUnixSocketAddress(address));
 	}
 
-	setenv("HOME", user->pw_dir, 1);
+	UPDATE_TRACE_POINT();
+	adminAddresses = options.getStrSet("logging_agent_admin_addresses",
+		false);
+	foreach (address, adminAddresses) {
+		wo->adminSockets.push_back(createServer(address));
+		if (getSocketAddressType(address) == SAT_UNIX) {
+			makeFileWorldReadableAndWritable(parseUnixSocketAddress(address));
+		}
+	}
 }
 
 static void
-maybeLowerPrivilege() {
-	struct passwd *user;
-	gid_t gid;
-
-	/* Sanity check user accounts. */
-
-	user = getpwnam(username.c_str());
-	if (user == NULL) {
-		throw NonExistentUserException(string("The configuration option ") +
-			"'PassengerAnalyticsLogUser' (Apache) or " +
-			"'passenger_analytics_log_user' (Nginx) was set to '" +
-			username + "', but this user doesn't exist. Please fix " +
-			"the configuration option.");
-	}
+lowerPrivilege() {
+	TRACE_POINT();
+	const VariantMap &options = *agentsOptions;
+	string userName = options.get("analytics_log_user", false);
+
+	if (geteuid() == 0 && !userName.empty()) {
+		string groupName = options.get("analytics_log_group", false);
+		struct passwd *pwUser = getpwnam(userName.c_str());
+		gid_t gid;
+
+		if (pwUser == NULL) {
+			throw RuntimeException("Cannot lookup user information for user " +
+				userName);
+		}
 
-	if (groupname.empty()) {
-		gid = user->pw_gid;
-		groupname = getGroupName(user->pw_gid);
-	} else {
-		gid = lookupGid(groupname);
-		if (gid == (gid_t) -1) {
-			throw NonExistentGroupException(string("The configuration option ") +
-				"'PassengerAnalyticsLogGroup' (Apache) or " +
-				"'passenger_analytics_log_group' (Nginx) was set to '" +
-				groupname + "', but this group doesn't exist. Please fix " +
-				"the configuration option.");
+		if (groupName.empty()) {
+			gid = pwUser->pw_gid;
+			groupName = getGroupName(pwUser->pw_gid);
+		} else {
+			gid = lookupGid(groupName);
+		}
+
+		if (initgroups(userName.c_str(), gid) != 0) {
+			int e = errno;
+			throw SystemException("Unable to lower " AGENT_EXE " logger's privilege "
+				"to that of user '" + userName + "' and group '" + groupName +
+				"': cannot set supplementary groups", e);
+		}
+		if (setgid(gid) != 0) {
+			int e = errno;
+			throw SystemException("Unable to lower " AGENT_EXE " logger's privilege "
+				"to that of user '" + userName + "' and group '" + groupName +
+				"': cannot set group ID to " + toString(gid), e);
 		}
+		if (setuid(pwUser->pw_uid) != 0) {
+			int e = errno;
+			throw SystemException("Unable to lower " AGENT_EXE " logger's privilege "
+				"to that of user '" + userName + "' and group '" + groupName +
+				"': cannot set user ID to " + toString(pwUser->pw_uid), e);
+		}
+
+		setenv("USER", pwUser->pw_name, 1);
+		setenv("HOME", pwUser->pw_dir, 1);
+		setenv("UID", toString(gid).c_str(), 1);
 	}
+}
 
-	/* Now's a good time to lower the privilege. */
-	if (geteuid() == 0) {
-		lowerPrivilege(username, user, gid);
+static void
+initializeUnprivilegedWorkingObjects() {
+	TRACE_POINT();
+	VariantMap &options = *agentsOptions;
+	WorkingObjects *wo = workingObjects;
+	int fd;
+
+	wo->resourceLocator = new ResourceLocator(options.get("passenger_root"));
+	options.set("union_station_gateway_cert", findUnionStationGatewayCert(
+		*wo->resourceLocator, options.get("union_station_gateway_cert", false)));
+
+	UPDATE_TRACE_POINT();
+	wo->bgloop = new BackgroundEventLoop(true, true);
+	wo->serverKitContext = new ServerKit::Context(wo->bgloop->safe);
+
+	UPDATE_TRACE_POINT();
+	wo->accountsDatabase = boost::make_shared<AccountsDatabase>();
+	wo->accountsDatabase->add("logging", wo->password, false);
+	wo->loggingServer = new LoggingServer(wo->bgloop->loop,
+		wo->serverSocketFd, wo->accountsDatabase, options);
+
+	UPDATE_TRACE_POINT();
+	wo->adminServer = new LoggingAgent::AdminServer(wo->serverKitContext);
+	wo->adminServer->loggingServer = wo->loggingServer;
+	wo->adminServer->exitEvent = &wo->exitEvent;
+	wo->adminServer->shutdownFinishCallback = adminServerShutdownFinished;
+	wo->adminServer->authorizations = wo->adminAuthorizations;
+	foreach (fd, wo->adminSockets) {
+		wo->adminServer->listen(fd);
 	}
+
+	UPDATE_TRACE_POINT();
+	ev_signal_init(&wo->sigquitWatcher, printInfo, SIGQUIT);
+	ev_signal_start(wo->bgloop->loop, &wo->sigquitWatcher);
+	ev_signal_init(&wo->sigintWatcher, onTerminationSignal, SIGINT);
+	ev_signal_start(wo->bgloop->loop, &wo->sigintWatcher);
+	ev_signal_init(&wo->sigtermWatcher, onTerminationSignal, SIGTERM);
+	ev_signal_start(wo->bgloop->loop, &wo->sigtermWatcher);
 }
 
-static struct ev_loop *
-createEventLoop() {
-	struct ev_loop *loop;
+static void
+reportInitializationInfo() {
+	TRACE_POINT();
 
-	// libev doesn't like choosing epoll and kqueue because the author thinks they're broken,
-	// so let's try to force it.
-	loop = ev_default_loop(EVBACKEND_EPOLL);
-	if (loop == NULL) {
-		loop = ev_default_loop(EVBACKEND_KQUEUE);
-	}
-	if (loop == NULL) {
-		loop = ev_default_loop(0);
+	P_NOTICE(AGENT_EXE " logger online, PID " << getpid());
+	if (feedbackFdAvailable()) {
+		writeArrayMessage(FEEDBACK_FD,
+			"initialized",
+			NULL);
 	}
-	if (loop == NULL) {
-		throw RuntimeException("Cannot create an event loop");
+}
+
+static void
+printInfo(EV_P_ struct ev_signal *watcher, int revents) {
+	cerr << "---------- Begin LoggingAgent status ----------\n";
+	workingObjects->loggingServer->dump(cerr);
+	cerr.flush();
+	cerr << "---------- End LoggingAgent status   ----------\n";
+}
+
+static void
+onTerminationSignal(EV_P_ struct ev_signal *watcher, int revents) {
+	WorkingObjects *wo = workingObjects;
+
+	// Start output after '^C'
+	printf("\n");
+
+	wo->terminationCount++;
+	if (wo->terminationCount < 3) {
+		P_NOTICE("Signal received. Gracefully shutting down... (send signal " <<
+			(3 - wo->terminationCount) << " more time(s) to force shutdown)");
+		workingObjects->exitEvent.notify();
 	} else {
-		return loop;
+		P_NOTICE("Signal received. Forcing shutdown.");
+		_exit(2);
 	}
 }
 
 static void
-initializeUnprivilegedWorkingObjects(WorkingObjects &wo) {
-	eventLoop = createEventLoop();
-	wo.accountsDatabase = boost::make_shared<AccountsDatabase>();
-	wo.accountsDatabase->add("logging", password, false);
-
-	wo.loggingServer = boost::make_shared<LoggingServer>(eventLoop, wo.serverSocketFd,
-		wo.accountsDatabase, agentsOptions);
-	loggingServer = wo.loggingServer.get();
-
-	wo.adminServer->addHandler(boost::make_shared<AdminController>(wo.loggingServer));
-	boost::function<void ()> adminServerFunc = boost::bind(&MessageServer::mainLoop, wo.adminServer.get());
-	wo.adminServerThread = boost::make_shared<oxt::thread>(
-		boost::bind(runAndPrintExceptions, adminServerFunc, true),
-		"AdminServer thread", MESSAGE_SERVER_THREAD_STACK_SIZE
-	);
+mainLoop() {
+	workingObjects->bgloop->start("Main event loop", 0);
+	waitForExitEvent();
 }
 
-void
-caughtExitSignal(ev::sig &watcher, int revents) {
-	P_INFO("Caught signal, exiting...");
-	ev_break(eventLoop, EVBREAK_ONE);
-	/* We only consider the "exit" command to be a graceful way to shut down
-	 * the logging agent, so upon receiving an exit signal we want to return
-	 * a non-zero exit code. This is because we want the watchdog to restart
-	 * the logging agent when it's killed by SIGTERM.
-	 */
-	exitCode = 1;
+static void
+shutdownAdminServer() {
+	workingObjects->adminServer->shutdown();
 }
 
-void
-printInfo(ev::sig &watcher, int revents) {
-	cerr << "---------- Begin LoggingAgent status ----------\n";
-	loggingServer->dump(cerr);
-	cerr.flush();
-	cerr << "---------- End LoggingAgent status   ----------\n";
+static void
+adminServerShutdownFinished(LoggingAgent::AdminServer *server) {
+	workingObjects->allClientsDisconnectedEvent.notify();
 }
 
+/* Wait until the watchdog closes the feedback fd (meaning it
+ * was killed) or until we receive an exit message.
+ */
 static void
-runMainLoop(WorkingObjects &wo) {
-	ev::io feedbackFdWatcher(eventLoop);
-	ev::sig sigintWatcher(eventLoop);
-	ev::sig sigtermWatcher(eventLoop);
-	ev::sig sigquitWatcher(eventLoop);
-
-	sigintWatcher.set<&caughtExitSignal>();
-	sigintWatcher.start(SIGINT);
-	sigtermWatcher.set<&caughtExitSignal>();
-	sigtermWatcher.start(SIGTERM);
-	sigquitWatcher.set<&printInfo>();
-	sigquitWatcher.start(SIGQUIT);
-
-	P_WARN("PassengerLoggingAgent online, listening at " << socketAddress);
+waitForExitEvent() {
+	this_thread::disable_syscall_interruption dsi;
+	WorkingObjects *wo = workingObjects;
+	fd_set fds;
+	int largestFd = -1;
+
+	FD_ZERO(&fds);
 	if (feedbackFdAvailable()) {
-		feedbackFdWatcher.set<&feedbackFdBecameReadable>();
-		feedbackFdWatcher.start(FEEDBACK_FD, ev::READ);
-		writeArrayMessage(FEEDBACK_FD, "initialized", NULL);
+		FD_SET(FEEDBACK_FD, &fds);
+		largestFd = std::max(largestFd, FEEDBACK_FD);
+	}
+	FD_SET(wo->exitEvent.fd(), &fds);
+	largestFd = std::max(largestFd, wo->exitEvent.fd());
+
+	TRACE_POINT();
+	if (syscalls::select(largestFd + 1, &fds, NULL, NULL, NULL) == -1) {
+		int e = errno;
+		throw SystemException("select() failed", e);
+	}
+
+	if (FD_ISSET(FEEDBACK_FD, &fds)) {
+		UPDATE_TRACE_POINT();
+		/* If the watchdog has been killed then we'll exit. There's no
+		 * point in keeping the logging agent running because we can't
+		 * detect when the web server exits, and because this logging
+		 * agent doesn't own the instance directory. As soon as
+		 * passenger-status is run, the instance directory will be
+		 * cleaned up, making the server inaccessible.
+		 */
+		_exit(2);
+	} else {
+		UPDATE_TRACE_POINT();
+		/* We received an exit command. */
+		P_NOTICE("Received command to shutdown gracefully. "
+			"Waiting until all clients have disconnected...");
+		wo->bgloop->safe->runLater(shutdownAdminServer);
+
+		UPDATE_TRACE_POINT();
+		FD_ZERO(&fds);
+		FD_SET(wo->allClientsDisconnectedEvent.fd(), &fds);
+		if (syscalls::select(wo->allClientsDisconnectedEvent.fd() + 1,
+			&fds, NULL, NULL, NULL) == -1)
+		{
+			int e = errno;
+			throw SystemException("select() failed", e);
+		}
+
+		P_INFO("All clients have now disconnected. Proceeding with graceful shutdown");
 	}
-	ev_run(eventLoop, 0);
 }
 
-int
-main(int argc, char *argv[]) {
-	initializeBareEssentials(argc, argv);
-	P_DEBUG("Starting PassengerLoggingAgent...");
+static void
+cleanup() {
+	TRACE_POINT();
+	WorkingObjects *wo = workingObjects;
+
+	P_DEBUG("Shutting down " AGENT_EXE " logger...");
+	wo->bgloop->stop();
+	delete wo->adminServer;
+	P_NOTICE(AGENT_EXE " logger shutdown finished");
+}
+
+static int
+runLoggingAgent() {
+	TRACE_POINT();
+	P_NOTICE("Starting " AGENT_EXE " logger...");
 
 	try {
-		TRACE_POINT();
-		WorkingObjects wo;
-
-		initializeOptions(wo);
-		initializePrivilegedWorkingObjects(wo);
-		maybeLowerPrivilege();
-		initializeUnprivilegedWorkingObjects(wo);
-		runMainLoop(wo);
-		P_DEBUG("Logging agent exiting with code " << exitCode << ".");
-		return exitCode;
+		UPDATE_TRACE_POINT();
+		initializePrivilegedWorkingObjects();
+		startListening();
+		lowerPrivilege();
+		initializeUnprivilegedWorkingObjects();
+
+		UPDATE_TRACE_POINT();
+		reportInitializationInfo();
+		mainLoop();
+
+		UPDATE_TRACE_POINT();
+		cleanup();
 	} catch (const tracable_exception &e) {
-		P_ERROR("*** ERROR: " << e.what() << "\n" << e.backtrace());
+		P_ERROR("ERROR: " << e.what() << "\n" << e.backtrace());
 		return 1;
 	}
+
+	return 0;
+}
+
+
+/***** Entry point and command line argument parsing *****/
+
+static void
+parseOptions(int argc, const char *argv[], VariantMap &options) {
+	OptionParser p(loggingAgentUsage);
+	int i = 2;
+
+	while (i < argc) {
+		if (parseLoggingAgentOption(argc, argv, i, options)) {
+			continue;
+		} else if (p.isFlag(argv[i], 'h', "--help")) {
+			loggingAgentUsage();
+			exit(0);
+		} else {
+			fprintf(stderr, "ERROR: unrecognized argument %s. Please type "
+				"'%s logger --help' for usage.\n", argv[i], argv[0]);
+			exit(1);
+		}
+	}
+}
+
+static void
+preinitialize(VariantMap &options) {
+	// Set log_level here so that initializeAgent() calls setLogLevel()
+	// and setLogFile() with the right value.
+	if (options.has("logging_agent_log_level")) {
+		options.setInt("log_level", options.getInt("logging_agent_log_level"));
+	}
+	if (options.has("logging_agent_log_file")) {
+		options.setInt("debug_log_file", options.getInt("logging_agent_log_file"));
+	}
+}
+
+static void
+setAgentsOptionsDefaults() {
+	VariantMap &options = *agentsOptions;
+	set<string> defaultAdminListenAddress;
+	defaultAdminListenAddress.insert(DEFAULT_LOGGING_AGENT_ADMIN_LISTEN_ADDRESS);
+
+	options.setDefault("logging_agent_address", DEFAULT_LOGGING_AGENT_LISTEN_ADDRESS);
+	options.setDefaultStrSet("logging_agent_admin_addresses", defaultAdminListenAddress);
+}
+
+static void
+sanityCheckOptions() {
+	VariantMap &options = *agentsOptions;
+	string webServerType = options.get("web_server_type", false);
+	bool ok = true;
+
+	if (!options.has("passenger_root")) {
+		fprintf(stderr, "ERROR: please set the --passenger-root argument.\n");
+		ok = false;
+	}
+
+	if (!options.has("logging_agent_password")
+	 && !options.has("logging_agent_password_file"))
+	{
+		fprintf(stderr, "ERROR: please set the --password-file argument.\n");
+		ok = false;
+	}
+
+	// Sanity check user accounts
+	string user = options.get("analytics_log_user", false);
+	if (!user.empty()) {
+		struct passwd *pwUser = getpwnam(user.c_str());
+		if (pwUser == NULL) {
+			fprintf(stderr, "ERROR: the username specified by --user, '%s', does not exist.\n",
+				user.c_str());
+			ok = false;
+		}
+
+		string group = options.get("analytics_log_group", false);
+		if (!group.empty() && lookupGid(group) == (gid_t) -1) {
+			fprintf(stderr, "ERROR: the group name specified by --group, '%s', does not exist.\n",
+				group.c_str());
+			ok = false;
+		}
+	} else if (options.has("analytics_log_group")) {
+		fprintf(stderr, "ERROR: setting --group also requires you to set --user.\n");
+		ok = false;
+	}
+
+	if (!ok) {
+		exit(1);
+	}
+}
+
+int
+loggingAgentMain(int argc, char *argv[]) {
+	agentsOptions = new VariantMap();
+	*agentsOptions = initializeAgent(argc, &argv, AGENT_EXE " logger",
+		parseOptions, preinitialize, 2);
+
+	CURLcode code = curl_global_init(CURL_GLOBAL_ALL);
+	if (code != CURLE_OK) {
+		P_CRITICAL("ERROR: Could not initialize libcurl: " << curl_easy_strerror(code));
+		exit(1);
+	}
+
+	setAgentsOptionsDefaults();
+	sanityCheckOptions();
+	return runLoggingAgent();
 }