passenger 4.0.20 → 4.0.21

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

@@ -84,7 +84,7 @@ private:
 	
 	typedef MessageServer::CommonClientContext CommonClientContext;
 	
-	shared_ptr<RequestHandler> requestHandler;
+	boost::shared_ptr<RequestHandler> requestHandler;
 	PoolPtr pool;
 	
 	
@@ -166,13 +166,13 @@ private:
 	}
 	
 public:
-	RemoteController(const shared_ptr<RequestHandler> &requestHandler, const PoolPtr &pool) {
+	RemoteController(const boost::shared_ptr<RequestHandler> &requestHandler, const PoolPtr &pool) {
 		this->requestHandler = requestHandler;
 		this->pool = pool;
 	}
 	
 	virtual MessageServer::ClientContextPtr newClient(CommonClientContext &commonContext) {
-		return make_shared<SpecificContext>();
+		return boost::make_shared<SpecificContext>();
 	}
 	
 	virtual bool processMessage(CommonClientContext &commonContext,
@@ -259,10 +259,10 @@ private:
 	AccountsDatabasePtr accountsDatabase;
 	MessageServerPtr messageServer;
 	ResourceLocator resourceLocator;
-	shared_ptr<RequestHandler> requestHandler;
-	shared_ptr<oxt::thread> prestarterThread;
-	shared_ptr<oxt::thread> messageServerThread;
-	shared_ptr<oxt::thread> eventLoopThread;
+	boost::shared_ptr<RequestHandler> requestHandler;
+	boost::shared_ptr<oxt::thread> prestarterThread;
+	boost::shared_ptr<oxt::thread> messageServerThread;
+	boost::shared_ptr<oxt::thread> eventLoopThread;
 	EventFd exitEvent;
 	
 	/**
@@ -421,12 +421,12 @@ public:
 		UPDATE_TRACE_POINT();
 		generation = serverInstanceDir.getGeneration(options.generationNumber);
 		startListening();
-		accountsDatabase = make_shared<AccountsDatabase>();
+		accountsDatabase = boost::make_shared<AccountsDatabase>();
 		accountsDatabase->add("_passenger-status", options.adminToolStatusPassword, false,
 			Account::INSPECT_BASIC_INFO | Account::INSPECT_SENSITIVE_INFO |
 			Account::INSPECT_BACKTRACES | Account::INSPECT_REQUESTS);
 		accountsDatabase->add("_web_server", options.exitPassword, false, Account::EXIT);
-		messageServer = make_shared<MessageServer>(
+		messageServer = boost::make_shared<MessageServer>(
 			parseUnixSocketAddress(options.adminSocketAddress), accountsDatabase);
 		
 		createFile(generation->getPath() + "/helper_agent.pid",
@@ -437,7 +437,7 @@ public:
 		}
 
 		UPDATE_TRACE_POINT();
-		randomGenerator = make_shared<RandomGenerator>();
+		randomGenerator = boost::make_shared<RandomGenerator>();
 		// Check whether /dev/urandom is actually random.
 		// https://code.google.com/p/phusion-passenger/issues/detail?id=516
 		if (randomGenerator->generateByteString(16) == randomGenerator->generateByteString(16)) {
@@ -446,21 +446,21 @@ public:
 		}
 		
 		UPDATE_TRACE_POINT();
-		loggerFactory = make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
+		loggerFactory = boost::make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
 			"logging", options.loggingAgentPassword);
-		spawnerFactory = make_shared<SpawnerFactory>(poolLoop.safe,
-			resourceLocator, generation, make_shared<SpawnerConfig>(randomGenerator));
-		pool = make_shared<Pool>(poolLoop.safe.get(), spawnerFactory, loggerFactory,
+		spawnerFactory = boost::make_shared<SpawnerFactory>(poolLoop.safe,
+			resourceLocator, generation, boost::make_shared<SpawnerConfig>(randomGenerator));
+		pool = boost::make_shared<Pool>(poolLoop.safe.get(), spawnerFactory, loggerFactory,
 			randomGenerator);
 		pool->initialize();
 		pool->setMax(options.maxPoolSize);
 		//pool->setMaxPerApp(maxInstancesPerApp);
 		pool->setMaxIdleTime(options.poolIdleTime * 1000000);
 		
-		requestHandler = make_shared<RequestHandler>(requestLoop.safe,
+		requestHandler = boost::make_shared<RequestHandler>(requestLoop.safe,
 			requestSocket, pool, options);
 
-		messageServer->addHandler(make_shared<RemoteController>(requestHandler, pool));
+		messageServer->addHandler(boost::make_shared<RemoteController>(requestHandler, pool));
 		messageServer->addHandler(ptr(new ExitHandler(exitEvent)));
 
 		sigquitWatcher.set(requestLoop.loop);
@@ -475,7 +475,7 @@ public:
 			messageServer->getSocketFilename().c_str(),
 			NULL);
 		
-		function<void ()> func = boost::bind(prestartWebApps,
+		boost::function<void ()> func = boost::bind(prestartWebApps,
 			resourceLocator,
 			options.defaultRubyCommand,
 			options.prestartUrls
@@ -531,7 +531,7 @@ public:
 	
 	void mainLoop() {
 		TRACE_POINT();
-		function<void ()> func;
+		boost::function<void ()> func;
 
 		func = boost::bind(&MessageServer::mainLoop, messageServer.get());
 		messageServerThread = ptr(new oxt::thread(

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

@@ -244,7 +244,7 @@ main() {
 	setLogLevel(3);
 	MultiLibeio::init();
 	loop = EV_DEFAULT;
-	libev = make_shared<SafeLibev>(loop);
+	libev = boost::make_shared<SafeLibev>(loop);
 	AgentOptions options;
 	ServerInstanceDir serverInstanceDir(getpid());
 	char root[PATH_MAX];
@@ -258,12 +258,12 @@ main() {
 	options.loggingAgentAddress = "unix:/tmp/agent";
 	options.loggingAgentPassword = "1234";
 
-	SpawnerFactoryPtr spawnerFactory = make_shared<SpawnerFactory>(libev,
+	SpawnerFactoryPtr spawnerFactory = boost::make_shared<SpawnerFactory>(libev,
 		ResourceLocator(root),
 		serverInstanceDir.newGeneration(true, "nobody", nogroup, getpid(), getgid()));
-	UnionStation::LoggerFactoryPtr loggerFactory = make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
+	UnionStation::LoggerFactoryPtr loggerFactory = boost::make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
 		"logging", options.loggingAgentPassword);
-	pool = make_shared<Pool>(libev.get(), spawnerFactory, loggerFactory);
+	pool = boost::make_shared<Pool>(libev.get(), spawnerFactory, loggerFactory);
 	FileDescriptor requestSocket(createTcpServer("127.0.0.1", 3000));
 	setNonBlocking(requestSocket);
 	handler = new RequestHandler(libev, requestSocket, pool, options);

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -120,6 +120,8 @@ using namespace ApplicationPool2;
 
 class RequestHandler;
 
+#define MAX_STATUS_HEADER_SIZE 64
+
 #define RH_ERROR(client, x) P_ERROR("[Client " << client->name() << "] " << x)
 #define RH_WARN(client, x) P_WARN("[Client " << client->name() << "] " << x)
 #define RH_DEBUG(client, x) P_DEBUG("[Client " << client->name() << "] " << x)
@@ -132,7 +134,7 @@ class RequestHandler;
 	RH_TRACE(client, 3, "Event: " eventName)
 
 
-class Client: public enable_shared_from_this<Client> {
+class Client: public boost::enable_shared_from_this<Client> {
 private:
 	struct ev_loop *getLoop() const;
 	const SafeLibevPtr &getSafeLibev() const;
@@ -290,19 +292,19 @@ public:
 	Client() {
 		fdnum = -1;
 
-		clientInput = make_shared< EventedBufferedInput<> >();
+		clientInput = boost::make_shared< EventedBufferedInput<> >();
 		clientInput->onData   = onClientInputData;
 		clientInput->onError  = onClientInputError;
 		clientInput->userData = this;
 		
-		clientBodyBuffer = make_shared<FileBackedPipe>("/tmp");
+		clientBodyBuffer = boost::make_shared<FileBackedPipe>("/tmp");
 		clientBodyBuffer->userData  = this;
 		clientBodyBuffer->onData    = onClientBodyBufferData;
 		clientBodyBuffer->onEnd     = onClientBodyBufferEnd;
 		clientBodyBuffer->onError   = onClientBodyBufferError;
 		clientBodyBuffer->onCommit  = onClientBodyBufferCommit;
 
-		clientOutputPipe = make_shared<FileBackedPipe>("/tmp");
+		clientOutputPipe = boost::make_shared<FileBackedPipe>("/tmp");
 		clientOutputPipe->userData  = this;
 		clientOutputPipe->onData    = onClientOutputPipeData;
 		clientOutputPipe->onEnd     = onClientOutputPipeEnd;
@@ -312,7 +314,7 @@ public:
 		clientOutputWatcher.set<Client, &Client::onClientOutputWritable>(this);
 
 		
-		appInput = make_shared< EventedBufferedInput<> >();
+		appInput = boost::make_shared< EventedBufferedInput<> >();
 		appInput->onData   = onAppInputData;
 		appInput->onError  = onAppInputError;
 		appInput->userData = this;
@@ -541,7 +543,7 @@ public:
 	}
 };
 
-typedef shared_ptr<Client> ClientPtr;
+typedef boost::shared_ptr<Client> ClientPtr;
 
 
 class RequestHandler {
@@ -897,15 +899,22 @@ private:
 		}
 		if (begin != string::npos && end != string::npos) {
 			StaticString statusValue(headerData.data() + begin + 1, end - begin);
-			char header[statusValue.size() + 20];
-			char *pos = header;
-			const char *end = header + statusValue.size() + 20;
+			if (statusValue.size() <= MAX_STATUS_HEADER_SIZE) {
+				char header[MAX_STATUS_HEADER_SIZE + sizeof("Status: \r\n")];
+				char *pos = header;
+				const char *end = header + sizeof(header);
 
-			pos = appendData(pos, end, "Status: ");
-			pos = appendData(pos, end, statusValue);
-			pos = appendData(pos, end, "\r\n");
-			headerData.append(StaticString(header, pos - header));
-			return true;
+				pos = appendData(pos, end, "Status: ");
+				pos = appendData(pos, end, statusValue);
+				pos = appendData(pos, end, "\r\n");
+				headerData.append(StaticString(header, pos - header));
+				return true;
+			} else {
+				disconnectWithError(client, "application sent malformed response: the Status header's (" +
+					statusValue + ") exceeds the allowed limit of " +
+					toString(MAX_STATUS_HEADER_SIZE) + " bytes.");
+				return false;
+			}
 		} else {
 			disconnectWithError(client, "application sent malformed response: the HTTP status line is invalid.");
 			return false;
@@ -1319,7 +1328,7 @@ private:
 					"\r\n"
 					"Benchmark point: after_accept\n");
 			} else {
-				ClientPtr client = make_shared<Client>();
+				ClientPtr client = boost::make_shared<Client>();
 				client->associate(this, fd);
 				clients.insert(make_pair<int, ClientPtr>(fd, client));
 				acceptedClients[count] = client;
@@ -1931,14 +1940,14 @@ private:
 		if (e != NULL) {
 			client->endScopeLog(&client->scopeLogs.getFromPool, false);
 			{
-				shared_ptr<RequestQueueFullException> e2 = dynamic_pointer_cast<RequestQueueFullException>(e);
+				boost::shared_ptr<RequestQueueFullException> e2 = dynamic_pointer_cast<RequestQueueFullException>(e);
 				if (e2 != NULL) {
 					writeRequestQueueFullExceptionErrorResponse(client);
 					return;
 				}
 			}
 			{
-				shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
+				boost::shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
 				if (e2 != NULL) {
 					writeSpawnExceptionErrorResponse(client, e2);
 					return;
@@ -1966,13 +1975,13 @@ private:
 			requestQueueOverflowStatusCode);
 	}
 
-	void writeSpawnExceptionErrorResponse(const ClientPtr &client, const shared_ptr<SpawnException> &e) {
+	void writeSpawnExceptionErrorResponse(const ClientPtr &client, const boost::shared_ptr<SpawnException> &e) {
 		if (strip(e->getErrorPage()).empty()) {
 			RH_WARN(client, "Cannot checkout session. " << e->what());
 			writeErrorResponse(client, e->what());
 		} else {
-			RH_WARN(client, "Cannot checkout session. " << e->what() <<
-				"\nError page:\n" << e->getErrorPage());
+			RH_WARN(client, "Cannot checkout session.\nError page:\n" <<
+				e->getErrorPage());
 			writeErrorResponse(client, e->getErrorPage(), e.get());
 		}
 	}
@@ -2000,7 +2009,7 @@ private:
 		response.append(typeName);
 		response.append("\nError message: ");
 		response.append(e->what());
-		shared_ptr<tracable_exception> e3 = dynamic_pointer_cast<tracable_exception>(e);
+		boost::shared_ptr<tracable_exception> e3 = dynamic_pointer_cast<tracable_exception>(e);
 		if (e3 != NULL) {
 			response.append("\nBacktrace:\n");
 			response.append(e3->backtrace());

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

@@ -67,7 +67,7 @@ public:
 	}
 	
 	virtual MessageServer::ClientContextPtr newClient(CommonClientContext &commonContext) {
-		return make_shared<SpecificContext>();
+		return boost::make_shared<SpecificContext>();
 	}
 	
 	virtual bool processMessage(CommonClientContext &commonContext,

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

@@ -38,6 +38,8 @@
 #endif
 #include <cstdio>
 #include <cstring>
+#include <string.h>
+#include <stdlib.h>
 
 #include <StaticString.h>
 #include <Exceptions.h>
@@ -834,10 +836,10 @@ private:
 	struct MultiExpression;
 	struct Comparison;
 	struct FunctionCall;
-	typedef shared_ptr<BooleanComponent> BooleanComponentPtr;
-	typedef shared_ptr<MultiExpression> MultiExpressionPtr;
-	typedef shared_ptr<Comparison> ComparisonPtr;
-	typedef shared_ptr<FunctionCall> FunctionCallPtr;
+	typedef boost::shared_ptr<BooleanComponent> BooleanComponentPtr;
+	typedef boost::shared_ptr<MultiExpression> MultiExpressionPtr;
+	typedef boost::shared_ptr<Comparison> ComparisonPtr;
+	typedef boost::shared_ptr<FunctionCall> FunctionCallPtr;
 	
 	struct BooleanComponent {
 		virtual ~BooleanComponent() { }
@@ -1380,7 +1382,7 @@ private:
 	
 	BooleanComponentPtr matchMultiExpression(int level) {
 		logMatch(level, "matchMultiExpression()");
-		MultiExpressionPtr result = make_shared<MultiExpression>();
+		MultiExpressionPtr result = boost::make_shared<MultiExpression>();
 		
 		result->firstExpression = matchExpression(level + 1);
 		while (isLogicalOperatorToken(peek())) {
@@ -1408,7 +1410,7 @@ private:
 			BooleanComponentPtr expression = matchMultiExpression(level + 1);
 			match(Tokenizer::RPARENTHESIS);
 			if (negate) {
-				return make_shared<Negation>(expression);
+				return boost::make_shared<Negation>(expression);
 			} else {
 				return expression;
 			}
@@ -1428,7 +1430,7 @@ private:
 			}
 			
 			if (negate) {
-				return make_shared<Negation>(component);
+				return boost::make_shared<Negation>(component);
 			} else {
 				return component;
 			}
@@ -1440,12 +1442,12 @@ private:
 	
 	BooleanComponentPtr matchSingleValueComponent(int level, const Token &token) {
 		logMatch(level, "matchSingleValueComponent()");
-		return make_shared<SingleValueComponent>(matchLiteral(level + 1, token));
+		return boost::make_shared<SingleValueComponent>(matchLiteral(level + 1, token));
 	}
 	
 	ComparisonPtr matchComparison(int level, const Token &subjectToken) {
 		logMatch(level, "matchComparison()");
-		ComparisonPtr comparison = make_shared<Comparison>();
+		ComparisonPtr comparison = boost::make_shared<Comparison>();
 		comparison->subject    = matchValue(level + 1, subjectToken);
 		comparison->comparator = matchComparator(level + 1);
 		comparison->object     = matchValue(level + 1, match());
@@ -1460,9 +1462,9 @@ private:
 		FunctionCallPtr function;
 		
 		if (id.rawValue == "starts_with") {
-			function = make_shared<StartsWithFunctionCall>();
+			function = boost::make_shared<StartsWithFunctionCall>();
 		} else if (id.rawValue == "has_hint") {
-			function = make_shared<HasHintFunctionCall>();
+			function = boost::make_shared<HasHintFunctionCall>();
 		} else {
 			raiseSyntaxError("unknown function '" + id.rawValue + "'", id);
 		}

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

@@ -74,7 +74,7 @@ private:
 	static const int GARBAGE_COLLECTION_TIMEOUT = 4500;  // 1 hour 15 minutes
 	
 	struct LogSink;
-	typedef shared_ptr<LogSink> LogSinkPtr;
+	typedef boost::shared_ptr<LogSink> LogSinkPtr;
 	typedef map<string, LogSinkPtr> LogSinkCache;
 	
 	struct LogSink {
@@ -183,7 +183,7 @@ private:
 		}
 	};
 	
-	typedef shared_ptr<LogFileSink> LogFileSinkPtr;
+	typedef boost::shared_ptr<LogFileSink> LogFileSinkPtr;
 	
 	struct RemoteSink: public LogSink {
 		/* RemoteSender compresses the data with zlib before sending it
@@ -363,7 +363,7 @@ private:
 		}
 	};
 	
-	typedef shared_ptr<Transaction> TransactionPtr;
+	typedef boost::shared_ptr<Transaction> TransactionPtr;
 	
 	enum ClientType {
 		UNINITIALIZED,
@@ -407,10 +407,10 @@ private:
 		}
 	};
 	
-	typedef shared_ptr<Client> ClientPtr;
+	typedef boost::shared_ptr<Client> ClientPtr;
 	typedef map<string, TransactionPtr> TransactionMap;
 	
-	typedef shared_ptr<FilterSupport::Filter> FilterPtr;
+	typedef boost::shared_ptr<FilterSupport::Filter> FilterPtr;
 	
 	RemoteSender remoteSender;
 	ev::timer garbageCollectionTimer;
@@ -543,7 +543,7 @@ private:
 		LogSinkCache::iterator it = logSinkCache.find(cacheKey);
 		if (it == logSinkCache.end()) {
 			trimLogSinkCache(MAX_LOG_SINK_CACHE_SIZE - 1);
-			result = make_shared<LogFileSink>(this, dumpFile);
+			result = boost::make_shared<LogFileSink>(this, dumpFile);
 			pair<LogSinkCache::iterator, bool> p =
 				logSinkCache.insert(make_pair(cacheKey, result));
 			result->cacheIterator = p.first;
@@ -573,7 +573,7 @@ private:
 		LogSinkCache::iterator it = logSinkCache.find(cacheKey);
 		if (it == logSinkCache.end()) {
 			trimLogSinkCache(MAX_LOG_SINK_CACHE_SIZE - 1);
-			result = make_shared<RemoteSink>(this, unionStationKey,
+			result = boost::make_shared<RemoteSink>(this, unionStationKey,
 				nodeName, category);
 			pair<LogSinkCache::iterator, bool> p =
 				logSinkCache.insert(make_pair(cacheKey, result));
@@ -625,7 +625,7 @@ private:
 		// TODO: garbage collect filters based on time
 		FilterPtr filter = filters.get(source);
 		if (filter == NULL) {
-			filter = make_shared<FilterSupport::Filter>(source);
+			filter = boost::make_shared<FilterSupport::Filter>(source);
 			filters.set(source, filter);
 		}
 		return *filter;
@@ -694,7 +694,7 @@ private:
 	}
 	
 	bool isDirectory(const string &dir, struct dirent *entry) const {
-		#if defined(__sun__) || defined(_AIX)
+		#if defined(__sun__) || defined(sun) || defined(_AIX)
 			string path = dir;
 			path.append("/");
 			path.append(entry->d_name);
@@ -869,7 +869,7 @@ protected:
 					return true;
 				}
 				
-				transaction = make_shared<Transaction>(this, ev_now(getLoop()));
+				transaction = boost::make_shared<Transaction>(this, ev_now(getLoop()));
 				if (unionStationKey.empty() || unionStationKey == "-") {
 					char tempNodeId[MD5_HEX_SIZE];
 					
@@ -1196,7 +1196,7 @@ public:
 	}
 };
 
-typedef shared_ptr<LoggingServer> LoggingServerPtr;
+typedef boost::shared_ptr<LoggingServer> LoggingServerPtr;
 
 
 } // namespace Passenger

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

@@ -75,7 +75,7 @@ struct WorkingObjects {
 	FileDescriptor serverSocketFd;
 	AccountsDatabasePtr adminAccountsDatabase;
 	MessageServerPtr adminServer;
-	shared_ptr<oxt::thread> adminServerThread;
+	boost::shared_ptr<oxt::thread> adminServerThread;
 	AccountsDatabasePtr accountsDatabase;
 	LoggingServerPtr loggingServer;
 
@@ -155,7 +155,7 @@ initializeOptions(WorkingObjects &wo) {
 	groupname          = agentsOptions.get("analytics_log_group", false);
 	adminToolStatusPassword = agentsOptions.get("admin_tool_status_password");
 
-	wo.resourceLocator = make_shared<ResourceLocator>(passengerRoot);
+	wo.resourceLocator = boost::make_shared<ResourceLocator>(passengerRoot);
 	agentsOptions.set("union_station_gateway_cert", findUnionStationGatewayCert(
 		*wo.resourceLocator, agentsOptions.get("union_station_gateway_cert", false)));
 }
@@ -175,9 +175,9 @@ initializePrivilegedWorkingObjects(WorkingObjects &wo) {
 		} while (ret == -1 && errno == EINTR);
 	}
 
-	wo.adminAccountsDatabase = make_shared<AccountsDatabase>();	
+	wo.adminAccountsDatabase = boost::make_shared<AccountsDatabase>();	
 	wo.adminAccountsDatabase->add("_passenger-status", adminToolStatusPassword, false);
-	wo.adminServer = make_shared<MessageServer>(parseUnixSocketAddress(adminSocketAddress),
+	wo.adminServer = boost::make_shared<MessageServer>(parseUnixSocketAddress(adminSocketAddress),
 		wo.adminAccountsDatabase);
 }
 
@@ -266,16 +266,16 @@ createEventLoop() {
 static void
 initializeUnprivilegedWorkingObjects(WorkingObjects &wo) {
 	eventLoop = createEventLoop();
-	wo.accountsDatabase = make_shared<AccountsDatabase>();
+	wo.accountsDatabase = boost::make_shared<AccountsDatabase>();
 	wo.accountsDatabase->add("logging", password, false);
 
-	wo.loggingServer = make_shared<LoggingServer>(eventLoop, wo.serverSocketFd,
+	wo.loggingServer = boost::make_shared<LoggingServer>(eventLoop, wo.serverSocketFd,
 		wo.accountsDatabase, agentsOptions);
 	loggingServer = wo.loggingServer.get();
 
-	wo.adminServer->addHandler(make_shared<AdminController>(wo.loggingServer));
-	function<void ()> adminServerFunc = boost::bind(&MessageServer::mainLoop, wo.adminServer.get());
-	wo.adminServerThread = make_shared<oxt::thread>(
+	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
 	);