passenger 5.0.4 → 5.0.5

data/ext/common/ServerKit/FileBufferedFdSinkChannel.h

@@ -97,12 +97,15 @@ public:
 		: errorCallback(NULL)
 	{
 		FileBufferedChannel::setDataCallback(onDataCallback);
+		watcher.active = false;
 		watcher.fd = -1;
 		watcher.data = this;
 	}
 
 	~FileBufferedFdSinkChannel() {
-		ev_io_stop(ctx->libev->getLoop(), &watcher);
+		if (ev_is_active(&watcher)) {
+			ev_io_stop(ctx->libev->getLoop(), &watcher);
+		}
 	}
 
 	// May only be called right after construction.
@@ -163,7 +166,9 @@ public:
 	}
 
 	void deinitialize() {
-		ev_io_stop(ctx->libev->getLoop(), &watcher);
+		if (ev_is_active(&watcher)) {
+			ev_io_stop(ctx->libev->getLoop(), &watcher);
+		}
 		watcher.fd = -1;
 		FileBufferedChannel::deinitialize();
 	}

data/ext/common/ServerKit/HttpServer.h

@@ -980,6 +980,12 @@ protected:
 		return false;
 	}
 
+	virtual void reinitializeClient(Client *client, int fd) {
+		ParentClass::reinitializeClient(client, fd);
+		client->requestsBegun = 0;
+		client->currentRequest = NULL;
+	}
+
 	virtual void reinitializeRequest(Client *client, Request *req) {
 		req->httpMajor = 1;
 		req->httpMinor = 0;

data/ext/common/ServerKit/Server.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -262,7 +262,7 @@ private:
 				break;
 			}
 
-			FdGuard guard(fd);
+			FdGuard guard(fd, NULL, 0);
 			client = checkoutClientObject();
 			TAILQ_INSERT_HEAD(&activeClients, client, nextClient.activeOrDisconnectedClient);
 			acceptedClients[acceptCount] = client;
@@ -271,6 +271,8 @@ private:
 			totalClientsAccepted++;
 			client->number = getNextClientNumber();
 			reinitializeClient(client, fd);
+			P_LOG_FILE_DESCRIPTOR_PURPOSE(fd, "Server " << getServerName()
+				<< ", client " << getClientName(client));
 			guard.clear();
 		}
 
@@ -327,7 +329,7 @@ private:
 			int fd = syscalls::accept(serverFd,
 				(struct sockaddr *) &u,
 				&addrlen);
-			FdGuard guard(fd);
+			FdGuard guard(fd, __FILE__, __LINE__);
 			if (fd == -1) {
 				return -1;
 			} else {
@@ -782,6 +784,8 @@ public:
 			acceptedClients[i] = client;
 			client->number = getNextClientNumber();
 			reinitializeClient(client, fds[i]);
+			P_LOG_FILE_DESCRIPTOR_PURPOSE(fds[i], "Server " << getServerName()
+				<< ", client " << getClientName(client));
 		}
 
 		SKS_DEBUG(size << " new client(s) accepted; there are now " <<
@@ -820,6 +824,12 @@ public:
 		return ret;
 	}
 
+	string getClientName(const Client *client) {
+		char buf[128];
+		unsigned int size = getClientName(client, buf, sizeof(buf));
+		return string(buf, size);
+	}
+
 	vector<ClientRefType> getActiveClients() {
 		vector<ClientRefType> result;
 		Client *client;
@@ -843,6 +853,22 @@ public:
 		return NULL;
 	}
 
+	Client *lookupClient(const StaticString &clientName) {
+		Client *client;
+
+		TAILQ_FOREACH (client, &activeClients, nextClient.activeOrDisconnectedClient) {
+			P_ASSERT_EQ(client->getConnState(), Client::ACTIVE);
+			char buf[512];
+			unsigned int size;
+
+			size = getClientName(client, buf, sizeof(buf));
+			if (StaticString(buf, size) == clientName) {
+				return client;
+			}
+		}
+		return NULL;
+	}
+
 	bool disconnect(int fd) {
 		assert(serverState != FINISHED_SHUTDOWN);
 		Client *client = lookupClient(fd);
@@ -853,6 +879,16 @@ public:
 		}
 	}
 
+	bool disconnect(const StaticString &clientName) {
+		assert(serverState != FINISHED_SHUTDOWN);
+		Client *client = lookupClient(clientName);
+		if (client != NULL) {
+			return disconnect(&client);
+		} else {
+			return false;
+		}
+	}
+
 	bool disconnect(Client **client) {
 		Client *c = *client;
 		if (c->getConnState() != Client::ACTIVE) {
@@ -874,6 +910,7 @@ public:
 		SKC_TRACE(c, 2, "Closing client file descriptor: " << fdnum);
 		try {
 			safelyClose(fdnum);
+			P_LOG_FILE_DESCRIPTOR_CLOSE(fdnum);
 		} catch (const SystemException &e) {
 			SKC_WARN(c, "An error occurred while closing the client file descriptor: " <<
 				e.what() << " (errno=" << e.code() << ")");

data/ext/common/StaticString.h

@@ -216,6 +216,26 @@ public:
 		return find(StaticString(s, n), pos);
 	}
 
+	string::size_type find_first_of(const StaticString &str, size_t pos = 0) const {
+		const char *current = content + pos;
+		const char *end = content + len;
+		const char *tokens = str.data();
+		const char *tokensEnd = str.data() + str.size();
+
+		while (current < end) {
+			const char *currentToken = tokens;
+			while (currentToken < tokensEnd) {
+				if (*current == *currentToken) {
+					return current - content;
+				}
+				currentToken++;
+			}
+			current++;
+		}
+
+		return string::npos;
+	}
+
 	StaticString substr(string::size_type pos = 0, string::size_type n = string::npos) const {
 		if (pos > len) {
 			throw out_of_range("Argument 'pos' out of range");

data/ext/common/UnionStation/Connection.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2014 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -36,6 +36,7 @@
 
 #include <errno.h>
 
+#include <Logging.h>
 #include <Exceptions.h>
 #include <Utils/IOUtils.h>
 #include <Utils/MessageIO.h>
@@ -164,6 +165,7 @@ struct Connection: public boost::noncopyable {
 			this_thread::disable_interruption di;
 			this_thread::disable_syscall_interruption dsi;
 			safelyClose(fd);
+			P_LOG_FILE_DESCRIPTOR_CLOSE(fd);
 			fd = -1;
 		}
 	}

data/ext/common/UnionStation/Core.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2014 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -142,9 +142,11 @@ private:
 		unsigned long long timeout = 15000000;
 
 		// Create socket.
-		fd = connectToServer(serverAddress);
-		FdGuard guard(fd, true);
-		
+		fd = connectToServer(serverAddress, __FILE__, __LINE__);
+		FdGuard guard(fd, NULL, 0, true);
+
+		P_LOG_FILE_DESCRIPTOR_PURPOSE(fd, "Connection to " AGENT_EXE " logger");
+
 		// Handshake: process protocol version number.
 		if (!readArrayMessage(fd, args, &timeout)) {
 			throw IOException("The logging agent closed the connection before sending a version identifier.");

data/ext/common/Utils.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2014 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -165,7 +165,8 @@ createFile(const string &filename, const StaticString &contents, mode_t permissi
 		options |= O_EXCL;
 	}
 	do {
-		fd = open(filename.c_str(), options, permissions);
+		fd.assign(open(filename.c_str(), options, permissions),
+			__FILE__, __LINE__);
 	} while (fd == -1 && errno == EINTR);
 	if (fd != -1) {
 		FileGuard guard(filename);
@@ -1036,7 +1037,7 @@ runCommandAndCaptureOutput(const char **command) {
 	int e;
 	Pipe p;
 
-	p = createPipe();
+	p = createPipe(__FILE__, __LINE__);
 
 	this_thread::disable_syscall_interruption dsi;
 	pid = syscalls::fork();

data/ext/common/Utils/DateParsing.h

@@ -49,7 +49,7 @@ inline bool parseImfFixdate_zone(const char **pos, const char *end, int &zone);
 
 
 /**
- * Parses an IMF-fixdate, as defined by RFC 5322.
+ * Parses an IMF-fixdate, as defined by RFC 7231 (while referencing RFC 5322).
  * Returns whether parsing succeeded.
  */
 inline bool
@@ -79,10 +79,24 @@ parseImfFixdate(const char *date, const char *end, struct tm &tm, int &zone) {
  */
 inline time_t
 parsedDateToTimestamp(struct tm &tm, int zone) {
-	time_t result = mktime(&tm);
-	result -= zone / 100 * 60 * 60 + zone % 100 * 60;
-	result += tm.tm_gmtoff;
-	return result;
+	time_t timeUsingLocalTZ = mktime(&tm);
+	// tmUsingLocalTZ now contains tm interpreted as being in our local timezone instead of the intended UTC
+	// Example: 10 UTC interpreted as 10 GMT+1 instead of 11 GMT+1
+
+#if !defined(sun) && !defined(__sun)
+	// tm_gmtoff = "seconds east of UTC", so the example 10 GMT+1 would now be corrected to (10+1) GMT+1
+	timeUsingLocalTZ += tm.tm_gmtoff;
+#else
+	// Solaris doesn't have tm_gmtoff, so we calculate the current offset by converting to UTC (gmtime) and pretending
+	// that is local time again (mktime), resulting in a "corrected" timestamp that we can delta with the original timestamp.
+	// In the example: gmtime(10 GMT+1) = 9 UTC, interpreted as 9 GMT+1 gives use delta (10 - 9) = +1 to correct 10 GMT+1 with.
+	struct tm *tmAsUTC = gmtime(&timeUsingLocalTZ);
+	time_t utcUsingLocalTZ = mktime(tmAsUTC);
+	timeUsingLocalTZ += (timeUsingLocalTZ - utcUsingLocalTZ);
+#endif
+
+	// The final result also needs to take into account the desired zone.
+	return timeUsingLocalTZ - (zone / 100 * 60 * 60 + zone % 100 * 60);
 }
 
 inline void

data/ext/common/Utils/FastStringStream.h

@@ -0,0 +1,183 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2015 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_FAST_STRING_STREAM_H_
+#define _PASSENGER_FAST_STRING_STREAM_H_
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <new>
+#include <cstdlib>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <oxt/macros.hpp>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * An std::streambuf-compatible string buffer. It's similar to std::stringbuf,
+ * with a few optimizations:
+ *
+ * - It uses an in-place storage area as long as the amount of data written
+ *   fits inside.
+ * - It allows direct read-only access to the storage area, in order to avoid
+ *   copying data.
+ */
+template<size_t staticCapacity = 1024>
+class FastStdStringBuf: public streambuf {
+public:
+	typedef char                  char_type;
+	typedef char_traits<char>     traits_type;
+	typedef traits_type::int_type int_type;
+	typedef traits_type::pos_type pos_type;
+	typedef traits_type::off_type off_type;
+	typedef string                string_type;
+
+	// Ensures that power-of-two doubling of staticCapacity works.
+	BOOST_STATIC_ASSERT(staticCapacity >= 4);
+
+private:
+	mutable char_type *bufend;
+	size_t dynamicCapacity;
+	union {
+		char staticBuffer[staticCapacity];
+		char *dynamicBuffer;
+	} u;
+
+	bool usingStaticBuffer() const {
+		return dynamicCapacity == 0;
+	}
+
+	boost::uint32_t nextPowerOf2(boost::uint32_t v) const {
+		v--;
+		v |= v >> 1;
+		v |= v >> 2;
+		v |= v >> 4;
+		v |= v >> 8;
+		v |= v >> 16;
+		v++;
+		return v;
+	}
+
+protected:
+	virtual int_type overflow(int_type ch = traits_type::eof()) {
+		size_t oldSize = size();
+		size_t newDynamicCapacity;
+		char *newDynamicBuffer;
+
+		if (usingStaticBuffer()) {
+			newDynamicCapacity = nextPowerOf2(2 * staticCapacity);
+			newDynamicBuffer = (char *) malloc(newDynamicCapacity);
+			if (OXT_UNLIKELY(newDynamicBuffer == NULL)) {
+				return traits_type::eof();
+			}
+			memcpy(newDynamicBuffer, u.staticBuffer, oldSize);
+		} else {
+			newDynamicCapacity = 2 * dynamicCapacity;
+			newDynamicBuffer = (char *) realloc(u.dynamicBuffer, newDynamicCapacity);
+			if (OXT_UNLIKELY(newDynamicBuffer == NULL)) {
+				return traits_type::eof();
+			}
+		}
+
+		dynamicCapacity = newDynamicCapacity;
+		u.dynamicBuffer = newDynamicBuffer;
+		setp(u.dynamicBuffer, u.dynamicBuffer + dynamicCapacity);
+
+		if (traits_type::eq_int_type(ch, traits_type::eof())) {
+			pbump(oldSize);
+		} else {
+			u.dynamicBuffer[oldSize] = ch;
+			pbump(oldSize + 1);
+		}
+
+		return traits_type::not_eof(ch);
+	}
+
+public:
+	FastStdStringBuf(unsigned int initialCapacity = 0) {
+		if (initialCapacity <= staticCapacity) {
+			dynamicCapacity = 0;
+			setp(u.staticBuffer, u.staticBuffer + staticCapacity);
+		} else {
+			dynamicCapacity = nextPowerOf2(initialCapacity);
+			u.dynamicBuffer = (char *) malloc(dynamicCapacity);
+			if (u.dynamicBuffer == NULL) {
+				throw std::bad_alloc();
+			}
+			setp(u.dynamicBuffer, u.dynamicBuffer + dynamicCapacity);
+		}
+	}
+
+	~FastStdStringBuf() {
+		if (!usingStaticBuffer()) {
+			free(u.dynamicBuffer);
+		}
+	}
+
+	const char *data() const {
+		return pbase();
+	}
+
+	size_t size() const {
+		return pptr() - pbase();
+	}
+
+	size_t capacity() const {
+		if (usingStaticBuffer()) {
+			return staticCapacity;
+		} else {
+			return dynamicCapacity;
+		}
+	}
+};
+
+/**
+ * An std::ostream-compatible output stream. It's similar to std::stringstream,
+ * with a few optimizations:
+ *
+ * - It uses an in-place storage area as long as the amount of data written
+ *   fits inside.
+ * - It allows direct read-only access to the storage area, in order to avoid
+ *   copying data.
+ *
+ * This class is implemented using FastStdStringBuf.
+ */
+template<size_t staticCapacity = 1024>
+class FastStringStream: public FastStdStringBuf<staticCapacity>, public ostream {
+public:
+	FastStringStream(unsigned int initialCapacity = 0)
+		: FastStdStringBuf<staticCapacity>(initialCapacity),
+		  ostream(this)
+		{ }
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_FAST_STRING_STREAM_H_ */