passenger 6.0.26 → 6.0.27

data/src/cxx_supportlib/Algorithms/Hasher.h

@@ -26,25 +26,22 @@
 #ifndef _PASSENGER_ALGORITHMS_HASHER_H_
 #define _PASSENGER_ALGORITHMS_HASHER_H_
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 namespace Passenger {
 
 
-// TODO: use SpookyHash on x86_64
-// TODO: use streaming murmurhash implementation: https://github.com/c9/murmur3
-
 struct JenkinsHash {
-	static const boost::uint32_t EMPTY_STRING_HASH = 0;
+	static const std::uint32_t EMPTY_STRING_HASH = 0;
 
-	boost::uint32_t hash;
+	std::uint32_t hash;
 
 	JenkinsHash()
 		: hash(0)
 		{ }
 
 	void update(const char *data, unsigned int size);
-	boost::uint32_t finalize();
+	std::uint32_t finalize();
 
 	void reset() {
 		hash = 0;

data/src/cxx_supportlib/Algorithms/MovingAverage.h

@@ -27,168 +27,9 @@
 #define _PASSENGER_ALGORITHMS_EXP_MOVING_AVERAGE_H_
 
 #include <oxt/macros.hpp>
-#include <boost/config.hpp>
-#include <algorithm>
-#include <utility>
-#include <cmath>
 
 namespace Passenger {
 
-using namespace std;
-
-
-/**
- * Implements discontiguous exponential moving averaging, as described by John C. Gunther
- * 1998. Can be used to compute moving exponentially decaying averages and standard
- * deviations. Unlike normal exponential moving average, this algorithm also works when
- * the data has gaps, and it also avoids initial value bias and postgap bias. See
- * http://www.drdobbs.com/tools/discontiguous-exponential-averaging/184410671
- *
- * ## Template parameters
- *
- * ### alpha
- *
- * Specifies by what factor data should decay. Its range is [0, 1000]. Higher values
- * cause the current value to have more weight (and thus the previous average
- * to decay more quickly), lower values have the opposite effect.
- *
- * ### alphaTimeUnit
- *
- * Specifies the time, in microseconds, after which the data should decay
- * by a factor of exactly `alpha`. For example, if `alpha = 0.5` and `alphaTimeUnit = 2000000`,
- * then data decays by 0.5 per 2 seconds.
- *
- * The default value is 1 second.
- *
- * ### maxAge
- *
- * Represents an educational guess as to how long (in microseconds) it takes
- * for the sampled data sequence to change significantly. If you don't expect large random
- * variations then you should set this to a large value. For a data sequence dominated by
- * large random variations, setting this to 1000000 (1 second) might be appropriate.
- *
- * If the time interval between updates is `dt`, using a `maxAge` of `N * dt` will cause
- * each update to fill in up to `N - 1` of any preceeding skipped updates with the current
- * data value.
- */
-template<
-	unsigned int alpha,
-	unsigned long long alphaTimeUnit = 1000000,
-	unsigned long long maxAge = 1000000
->
-class DiscExpMovingAverage {
-private:
-	template<unsigned int, unsigned long long, unsigned long long>
-	friend class DiscExpMovingAverageWithStddev;
-
-	double sumOfWeights, sumOfData;
-	unsigned long long prevTime;
-
-	static BOOST_CONSTEXPR double floatingAlpha() {
-		return alpha / 1000.0;
-	}
-
-	static BOOST_CONSTEXPR double newDataWeightUpperBound() {
-		return pow(floatingAlpha(), maxAge / (double) alphaTimeUnit);
-	}
-
-	pair<double, double> internalUpdate(double value, unsigned long long now) {
-		double weightReductionFactor = pow(1 - floatingAlpha(),
-			(now - prevTime) / (double) alphaTimeUnit);
-		double newDataWeight = std::min(1 - weightReductionFactor,
-			newDataWeightUpperBound());
-		sumOfWeights = weightReductionFactor * sumOfWeights + newDataWeight;
-		sumOfData = weightReductionFactor * sumOfData + newDataWeight * value;
-		prevTime = now;
-		return make_pair(weightReductionFactor, newDataWeight);
-	}
-
-public:
-	DiscExpMovingAverage(unsigned long long _prevTime = 0)
-		: sumOfWeights(0),
-		  sumOfData(0),
-		  prevTime(_prevTime)
-		{ }
-
-	void update(double value, unsigned long long now) {
-		if (OXT_LIKELY(now > prevTime)) {
-			internalUpdate(value, now);
-		}
-	}
-
-	bool available() const {
-		return sumOfWeights > 0;
-	}
-
-	double completeness(unsigned long long now) const {
-		return pow(floatingAlpha(), now - prevTime) * sumOfWeights;
-	}
-
-	double average() const {
-		return sumOfData / sumOfWeights;
-	}
-
-	double average(unsigned long long now) const {
-		DiscExpMovingAverage<alpha, alphaTimeUnit, maxAge> copy(*this);
-		copy.update(0, now);
-		return copy.average();
-	}
-};
-
-
-/**
- * Like DescExpMovingAverage, but also keeps track of the standard deviation.
- */
-template<
-	unsigned int alpha,
-	unsigned long long alphaTimeUnit = 1000000,
-	unsigned long long maxAge = 1
->
-class DiscExpMovingAverageWithStddev {
-private:
-	DiscExpMovingAverage<alpha, alphaTimeUnit, maxAge> dema;
-	double sumOfSquaredData;
-
-public:
-	DiscExpMovingAverageWithStddev(unsigned long long prevTime = 0)
-		: dema(prevTime),
-		  sumOfSquaredData(0)
-		{ }
-
-	void update(double value, unsigned long long now) {
-		if (OXT_UNLIKELY(now <= dema.prevTime)) {
-			return;
-		}
-
-		pair<double, double> p = dema.internalUpdate(value, now);
-		double weightReductionFactor = p.first;
-		double newDataWeight = p.second;
-		sumOfSquaredData = weightReductionFactor * sumOfSquaredData
-			+ newDataWeight * pow(value, 2.0);
-	}
-
-	bool available() const {
-		return dema.available();
-	}
-
-	double completeness(unsigned long long now) const {
-		return dema.completeness(now);
-	}
-
-	double average() const {
-		return dema.average();
-	}
-
-	double average(unsigned long long now) const {
-		return dema.average(now);
-	}
-
-	double stddev() const {
-		return sqrt(sumOfSquaredData / dema.sumOfWeights - pow(average(), 2));
-	}
-};
-
-
 /**
  * Calculates an exponential moving average. `alpha` determines how much weight the
  * current value has compared to the previous average. Higher values of `alpha`
@@ -197,7 +38,7 @@ public:
  *
  * This algorithm is not timing sensitive: it doesn't take into account gaps in the
  * data over time, and treats all values equally regardless of when the value was
- * collected. See also DiscExpMovingAverage.
+ * collected.
  *
  * You should initialize the the average value with a value equal to `nullValue`.
  * If `prevAverage` equals `nullValue` then this function simply returns `currentValue`.

data/src/cxx_supportlib/Constants.h

@@ -50,6 +50,7 @@
 #define DEFAULT_APP_THREAD_COUNT 1
 #define DEFAULT_BIND_ADDRESS "127.0.0.1"
 #define DEFAULT_CONCURRENCY_MODEL "process"
+#define DEFAULT_CONNECT_TIMEOUT 30
 #define DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD 131072
 #define DEFAULT_HTTP_SERVER_LISTEN_ADDRESS "tcp://127.0.0.1:3000"
 #define DEFAULT_INTEGRATION_MODE "standalone"
@@ -83,7 +84,7 @@
 #define PASSENGER_API_VERSION_MAJOR 0
 #define PASSENGER_API_VERSION_MINOR 3
 #define PASSENGER_DEFAULT_USER "nobody"
-#define PASSENGER_VERSION "6.0.26"
+#define PASSENGER_VERSION "6.0.27"
 #define POOL_HELPER_THREAD_STACK_SIZE 262144
 #define PROCESS_SHUTDOWN_TIMEOUT 60
 #define PROCESS_SHUTDOWN_TIMEOUT_DISPLAY "1 minute"

data/src/cxx_supportlib/DataStructures/StringMap.h

@@ -28,9 +28,8 @@
 
 #include <string>
 #include <utility>
-
+#include <unordered_map>
 #include <StaticString.h>
-#include <DataStructures/HashMap.h>
 
 namespace Passenger {
 
@@ -54,7 +53,7 @@ private:
 		pair<StaticString, T> thePair;
 	};
 
-	typedef HashMap<StaticString, Entry, StaticString::Hash> InternalMap;
+	typedef std::unordered_map<StaticString, Entry, StaticString::Hash> InternalMap;
 	typedef typename InternalMap::iterator InternalIterator;
 	typedef typename InternalMap::const_iterator InternalConstIterator;
 	typedef typename InternalMap::value_type ValueType;

data/src/cxx_supportlib/FileTools/FileManip.h

@@ -226,6 +226,8 @@ void makeDirTree(const string &path, const StaticString &mode = "u=rwx,g=,o=",
  * function does nothing.
  *
  * @throws RuntimeException Something went wrong.
+ * @throws SystemException
+ * @throws boost::thread_interrupted
  */
 void removeDirTree(const string &path);
 

data/src/cxx_supportlib/Hooks.h

@@ -34,7 +34,6 @@
 #include <oxt/backtrace.hpp>
 
 #include <cstdio>
-#include <cerrno>
 #include <cstring>
 #include <cctype>
 #include <stdlib.h>

data/src/cxx_supportlib/IOTools/IOUtils.cpp

@@ -34,7 +34,6 @@
 #include <oxt/system_calls.hpp>
 #include <oxt/backtrace.hpp>
 #include <oxt/macros.hpp>
-#include <algorithm>
 #include <string>
 #include <vector>
 #include <sys/socket.h>
@@ -42,10 +41,9 @@
 #include <sys/un.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
-#include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
-#include <limits.h> // Also for __GLIBC__ macro.
+#include <limits.h> // IWYU pragma: keep; for __GLIBC__ macro
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -240,56 +238,12 @@ callAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options) {
 			ret = ::accept4(sock, addr, addr_len, options);
 		} while (ret == -1 && errno == EINTR);
 		return ret;
-	#elif defined(__linux__) && defined(__x86_64__)
-		int ret;
-		do {
-			ret = syscall(288, sock, addr, addr_len, options);
-		} while (ret == -1 && errno == EINTR);
-		return ret;
 	#else
 		errno = ENOSYS;
 		return -1;
 	#endif
 }
 
-vector<string>
-resolveHostname(const string &hostname, unsigned int port, bool shuffle) {
-	string portString = toString(port);
-	struct addrinfo hints, *res, *current;
-	vector<string> result;
-	int ret;
-
-	memset(&hints, 0, sizeof(hints));
-	hints.ai_family   = PF_UNSPEC;
-	hints.ai_socktype = SOCK_STREAM;
-	ret = getaddrinfo(hostname.c_str(), (port == 0) ? NULL : portString.c_str(),
-		&hints, &res);
-	if (ret != 0) {
-		throw IOException(string("Error resolving ") + hostname + ": "
-			+ gai_strerror(ret));
-	}
-
-	for (current = res; current != NULL; current = current->ai_next) {
-		char host[NI_MAXHOST];
-
-		ret = getnameinfo(current->ai_addr, current->ai_addrlen,
-			host, sizeof(host) - 1,
-			NULL, 0,
-			NI_NUMERICHOST);
-		if (ret == 0) {
-			result.push_back(host);
-		} else {
-			P_WARN("Cannot get name info for one of the resolved "
-				"IP addresses in host name " << hostname);
-		}
-	}
-	freeaddrinfo(res);
-	if (shuffle) {
-		random_shuffle(result.begin(), result.end());
-	}
-	return result;
-}
-
 int
 createServer(const StaticString &address, unsigned int backlogSize, bool autoDelete,
 	const char *file, unsigned int line)
@@ -572,6 +526,7 @@ connectToUnixServer(NUnix_State &state) {
 			int e = errno;
 			string message = "Cannot connect to Unix socket '";
 			message.append(state.filename.data(), state.filename.size());
+			message.append("'");
 			throw SystemException(message, e);
 		}
 	} else {
@@ -696,15 +651,13 @@ connectToTcpServer(NTCP_State &state) {
 	}
 }
 
-void
-setupNonBlockingSocket(NConnect_State &state, const StaticString &address,
-	const char *file, unsigned int line)
+NConnect_State::NConnect_State(const StaticString &address, const char *file, unsigned int line)
 {
 	TRACE_POINT();
-	state.type = getSocketAddressType(address);
-	switch (state.type) {
+	type = getSocketAddressType(address);
+	switch (type) {
 	case SAT_UNIX:
-		setupNonBlockingUnixSocket(state.s_unix, parseUnixSocketAddress(address),
+		setupNonBlockingUnixSocket(s_unix, parseUnixSocketAddress(address),
 			file, line);
 		break;
 	case SAT_TCP: {
@@ -712,7 +665,7 @@ setupNonBlockingSocket(NConnect_State &state, const StaticString &address,
 		unsigned short port;
 
 		parseTcpSocketAddress(address, host, port);
-		setupNonBlockingTcpSocket(state.s_tcp, host, port, file, line);
+		setupNonBlockingTcpSocket(s_tcp, host, port, file, line);
 		break;
 	}
 	default:
@@ -721,17 +674,51 @@ setupNonBlockingSocket(NConnect_State &state, const StaticString &address,
 }
 
 bool
-connectToServer(NConnect_State &state) {
-	switch (state.type) {
+NConnect_State::connectToServer() {
+	switch (type) {
 	case SAT_UNIX:
-		return connectToUnixServer(state.s_unix);
+		return connectToUnixServer(s_unix);
 	case SAT_TCP:
-		return connectToTcpServer(state.s_tcp);
+		return connectToTcpServer(s_tcp);
 	default:
 		throw RuntimeException("Unknown address type");
 	}
 }
 
+FileDescriptor &
+NConnect_State::getFd() {
+	switch (type) {
+	case SAT_UNIX:
+		return s_unix.fd;
+	case SAT_TCP:
+		return s_tcp.fd;
+	default:
+		throw RuntimeException("Unknown address type");
+	}
+}
+
+NUnix_State &
+NConnect_State::asNUnix_State() {
+	// When we're ready for C++14:
+	// if (type == SAT_UNIX) {
+	// 	return *reinterpret_cast<NUnix_State *>(storage);
+	// } else {
+	// 	P_BUG("Address type is not TCP");
+	// }
+	return s_unix;
+}
+
+NTCP_State &
+NConnect_State::asNTCP_State() {
+	// When we're ready for C++14:
+	// if (type == SAT_TCP) {
+	// 	return *reinterpret_cast<NTCP_State *>(storage);
+	// } else {
+	// 	P_BUG("Address type is not TCP");
+	// }
+	return s_tcp;
+}
+
 bool
 pingTcpServer(const StaticString &host, unsigned int port, unsigned long long *timeout) {
 	TRACE_POINT();
@@ -1209,7 +1196,8 @@ readFileDescriptor(int fd, unsigned long long *timeout) {
 
 	ret = syscalls::recvmsg(fd, &msg, 0);
 	if (ret == -1) {
-		throw SystemException("Cannot read file descriptor with recvmsg()", errno);
+		int err = errno;
+		throw SystemException("Cannot read file descriptor with recvmsg()", err);
 	}
 
 	control_header = CMSG_FIRSTHDR(&msg);
@@ -1279,7 +1267,8 @@ writeFileDescriptor(int fd, int fdToSend, unsigned long long *timeout) {
 
 	ret = syscalls::sendmsg(fd, &msg, 0);
 	if (ret == -1) {
-		throw SystemException("Cannot send file descriptor with sendmsg()", errno);
+		int err = errno;
+		throw SystemException("Cannot send file descriptor with sendmsg()", err);
 	}
 }
 

data/src/cxx_supportlib/IOTools/IOUtils.h

@@ -35,7 +35,6 @@
 #include <netdb.h>
 #include <string>
 #include <utility>
-#include <vector>
 #include <oxt/macros.hpp>
 #include <StaticString.h>
 #include <FileDescriptor.h>
@@ -121,23 +120,6 @@ int callAccept4(int sock,
 	socklen_t * restrict addr_len,
 	int options);
 
-/**
- * Resolves the given host name and returns a list of IP addresses.
- * `hostname` may also be an IP address, in which case it is
- * returned. You may explicitly specify a `port` as a hint to
- * the DNS resolver; set to 0 if you don't care or can't provide a
- * port number.
- *
- * If `shuffle` is set, and the host name resolves to multiple
- * IP addresses, then these addresses will be shuffled before they are
- * returned in order to improve load balancing.
- *
- * @throws IOException DNS resolution failure.
- */
-vector<string> resolveHostname(const string &hostname,
-	unsigned int port = 0,
-	bool shuffle = true);
-
 /**
  * Create a new Unix or TCP server socket, depending on the address type.
  *
@@ -260,12 +242,33 @@ int connectToUnixServer(const StaticString &filename, const char *file,
 int connectToTcpServer(const StaticString &hostname, unsigned int port,
 	const char *file, unsigned int line);
 
+
 /** State structure for non-blocking connectToUnixServer(). */
 struct NUnix_State {
 	FileDescriptor fd;
 	string filename;
 };
 
+/** State structure for non-blocking connectToTcpServer(). */
+struct NTCP_State {
+	FileDescriptor fd;
+	struct addrinfo hints, *res;
+	string hostname;
+	int port;
+
+	NTCP_State() {
+		memset(&hints, 0, sizeof(hints));
+		res = NULL;
+		port = 0;
+	}
+
+	~NTCP_State() {
+		if (res != NULL) {
+			freeaddrinfo(res);
+		}
+	}
+};
+
 /**
  * Setup a Unix domain socket for non-blocking connecting. When done,
  * the file descriptor can be accessed through <tt>state.fd</tt>.
@@ -296,26 +299,6 @@ void setupNonBlockingUnixSocket(NUnix_State & restrict_ref state,
  */
 bool connectToUnixServer(NUnix_State &state);
 
-/** State structure for non-blocking connectToTcpServer(). */
-struct NTCP_State {
-	FileDescriptor fd;
-	struct addrinfo hints, *res;
-	string hostname;
-	int port;
-
-	NTCP_State() {
-		memset(&hints, 0, sizeof(hints));
-		res = NULL;
-		port = 0;
-	}
-
-	~NTCP_State() {
-		if (res != NULL) {
-			freeaddrinfo(res);
-		}
-	}
-};
-
 /**
  * Setup a TCP socket for non-blocking connecting. When done,
  * the file descriptor can be accessed through <tt>state.fd</tt>.
@@ -348,42 +331,49 @@ void setupNonBlockingTcpSocket(NTCP_State & restrict_ref state,
 bool connectToTcpServer(NTCP_State &state);
 
 struct NConnect_State {
-	ServerAddressType type;
+private:
 	NUnix_State s_unix;
 	NTCP_State s_tcp;
-};
 
-/**
- * Setup a socket for non-blocking connecting to the given address.
- *
- * @param A state structure.
- * @param address An address as accepted by getSocketAddressType().
- * @param file The name of the source file that called this function,
- *             for file descriptor logging purposes.
- * @param line The line in the source file that called this function.
- * @throws ArgumentException Unknown address type.
- * @throws RuntimeException Something went wrong.
- * @throws SystemException Something went wrong.
- * @throws IOException Something went wrong.
- * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
- */
-void setupNonBlockingSocket(NConnect_State & restrict_ref state,
-	const StaticString & restrict_ref address, const char *file,
-	unsigned int line);
+public:
+	ServerAddressType type;
 
-/**
- * Connect a socket in non-blocking mode.
- *
- * @param state A state structure.
- * @return True if the socket was successfully connected, false if the socket isn't
- *         ready yet, in which case the caller should select() on the socket until it's writable.
- * @throws RuntimeException Something went wrong.
- * @throws SystemException Something went wrong.
- * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
- */
-bool connectToServer(NConnect_State &state);
+	/**
+	 * Setup a socket for non-blocking connecting to the given address.
+	 *
+	 * @param address An address as accepted by getSocketAddressType().
+	 * @param file The name of the source file that called this function,
+	 *             for file descriptor logging purposes.
+	 * @param line The line in the source file that called this function.
+	 * @throws ArgumentException Unknown address type.
+	 * @throws RuntimeException Something went wrong.
+	 * @throws SystemException Something went wrong.
+	 * @throws IOException Something went wrong.
+	 * @throws boost::thread_interrupted A system call has been interrupted.
+	 */
+	NConnect_State(const StaticString & restrict_ref address, const char *file, unsigned int line);
+
+	NUnix_State &asNUnix_State();
+	NTCP_State &asNTCP_State();
+
+	/**
+	 * Connect a socket in non-blocking mode.
+	 *
+	 * @return True if the socket was successfully connected, false if the socket isn't
+	 *         ready yet, in which case the caller should select() on the socket until it's writable.
+	 * @throws RuntimeException Something went wrong.
+	 * @throws SystemException Something went wrong.
+	 * @throws boost::thread_interrupted A system call has been interrupted.
+	 */
+	bool connectToServer();
+
+	/**
+	 * Gets the connection file descriptor.
+	 *
+	 * @pre \c connectToServer() was called
+	 */
+	FileDescriptor &getFd();
+};
 
 /**
  * Checks whether the given TCP server is connectable. Because this check
@@ -451,9 +441,11 @@ bool waitUntilReadable(int fd, unsigned long long *timeout);
 bool waitUntilWritable(int fd, unsigned long long *timeout);
 
 /**
- * Attempts to read exactly <tt>size</tt> bytes of data from the given file
- * descriptor, and put the result in <tt>buf</tt>. On non-blocking sockets
- * this function will block by poll()ing the socket.
+ * Attempts to read exactly `size` bytes of data, putting the result in `buf`.
+ * This is in contrast to read(), which may read less than `size` bytes even
+ * when EOF is not reached.
+ *
+ * On non-blocking sockets, this function blocks by poll()ing the socket.
  *
  * @param buf The buffer to place the read data in. This buffer must be at least
  *            <tt>size</tt> bytes long.

data/src/cxx_supportlib/ServerKit/AcceptLoadBalancer.h

@@ -43,6 +43,8 @@
 
 #include <Constants.h>
 #include <LoggingKit/LoggingKit.h>
+#include <ServerKit/Context.h>
+#include <ServerKit/Errors.h>
 #include <Utils.h>
 #include <IOTools/IOUtils.h>
 

data/src/cxx_supportlib/ServerKit/HttpHeaderParser.h

@@ -133,14 +133,16 @@ private:
 			goto happy_path;
 		case HPE_OK:
 			rc = llhttp_execute(parser, data, len);
-		happy_path:
-			if (rc == HPE_OK) {
-				return len;
-            }
-			// deliberate fall through
-        default:
+			goto happy_path;
+		default:
 			return (llhttp_get_error_pos(parser) - data);
 		}
+
+		happy_path:
+		if (rc == HPE_OK) {
+			return len;
+		}
+		return (llhttp_get_error_pos(parser) - data);
 	}
 
 	static int _onURL(llhttp_t *parser, const char *data, size_t len) {

data/src/cxx_supportlib/StrIntTools/StrIntUtils.h

@@ -45,8 +45,8 @@ using namespace std;
 
 
 /**
- * A RAII construct for memory buffers that are dynamically allocated with malloc().
- * Upon destruction of a DynamicBuffer, the memory buffer is freed.
+ * RAII construct for memory buffers that are dynamically allocated with malloc().
+ * Upon destruction, the memory buffer is freed. Does not guarantee null terminator.
  */
 struct DynamicBuffer {
 private: