passenger 6.0.27 → 6.1.0

data/src/cxx_supportlib/IOTools/IOUtils.cpp

@@ -29,6 +29,7 @@
 	// https://bugzilla.redhat.com/show_bug.cgi?id=165427
 	// Also needed for SO_PEERCRED.
 	#define _GNU_SOURCE
+#include <exception>
 #endif
 
 #include <oxt/system_calls.hpp>
@@ -86,18 +87,7 @@ using namespace oxt;
 static WritevFunction writevFunction = syscalls::writev;
 
 
-bool
-purgeStdio(FILE *f) {
-	#if defined(HAVE_FPURGE)
-		fpurge(f);
-		return true;
-	#elif defined(HAVE___FPURGE)
-		__fpurge(f);
-		return true;
-	#else
-		return false;
-	#endif
-}
+/****** Server address types support ******/
 
 ServerAddressType
 getSocketAddressType(const StaticString &address) {
@@ -182,67 +172,8 @@ isLocalSocketAddress(const StaticString &address) {
 	}
 }
 
-void
-setBlocking(int fd) {
-	int flags, ret;
-
-	do {
-		flags = fcntl(fd, F_GETFL);
-	} while (flags == -1 && errno == EINTR);
-	if (flags == -1) {
-		int e = errno;
-		throw SystemException("Cannot set socket to blocking mode: "
-			"cannot get socket flags",
-			e);
-	}
-	do {
-		ret = fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
-	} while (ret == -1 && errno == EINTR);
-	if (ret == -1) {
-		int e = errno;
-		throw SystemException("Cannot set socket to blocking mode: "
-			"cannot set socket flags",
-			e);
-	}
-}
 
-void
-setNonBlocking(int fd) {
-	int flags, ret;
-
-	do {
-		flags = fcntl(fd, F_GETFL);
-	} while (flags == -1 && errno == EINTR);
-	if (flags == -1) {
-		int e = errno;
-		throw SystemException("Cannot set socket to non-blocking mode: "
-			"cannot get socket flags",
-			e);
-	}
-	do {
-		ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-	} while (ret == -1 && errno == EINTR);
-	if (ret == -1) {
-		int e = errno;
-		throw SystemException("Cannot set socket to non-blocking mode: "
-			"cannot set socket flags",
-			e);
-	}
-}
-
-int
-callAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options) {
-	#if defined(HAVE_ACCEPT4)
-		int ret;
-		do {
-			ret = ::accept4(sock, addr, addr_len, options);
-		} while (ret == -1 && errno == EINTR);
-		return ret;
-	#else
-		errno = ENOSYS;
-		return -1;
-	#endif
-}
+/****** Server socket creation ******/
 
 int
 createServer(const StaticString &address, unsigned int backlogSize, bool autoDelete,
@@ -285,7 +216,7 @@ createUnixServer(const StaticString &filename, unsigned int backlogSize, bool au
 		throw SystemException("Cannot create a Unix socket file descriptor", e);
 	}
 
-	FdGuard guard(fd, file, line, true);
+	FdGuard guard(fd, file, line);
 	addr.sun_family = AF_LOCAL;
 	strncpy(addr.sun_path, filename.c_str(), filename.size());
 	addr.sun_path[filename.size()] = '\0';
@@ -376,7 +307,7 @@ createTcpServer(const char *address, unsigned short port, unsigned int backlogSi
 	}
 	// Ignore SO_REUSEADDR error, it's not fatal.
 
-	FdGuard guard(fd, file, line, true);
+	FdGuard guard(fd, file, line);
 	if (family == AF_INET) {
 		ret = syscalls::bind(fd, (const struct sockaddr *) &addr.v4, sizeof(struct sockaddr_in));
 	} else {
@@ -408,6 +339,9 @@ createTcpServer(const char *address, unsigned short port, unsigned int backlogSi
 	return fd;
 }
 
+
+/****** Socket connection establishment (blocking) ******/
+
 int
 connectToServer(const StaticString &address, const char *file, unsigned int line) {
 	TRACE_POINT();
@@ -436,7 +370,7 @@ connectToUnixServer(const StaticString &filename, const char *file,
 		throw SystemException("Cannot create a Unix socket file descriptor", e);
 	}
 
-	FdGuard guard(fd, file, line, true);
+	FdGuard guard(fd, file, line);
 	int ret;
 	struct sockaddr_un addr;
 
@@ -486,54 +420,6 @@ connectToUnixServer(const StaticString &filename, const char *file,
 	abort();   // Never reached.
 }
 
-void
-setupNonBlockingUnixSocket(NUnix_State &state, const StaticString &filename,
-	const char *file, unsigned int line)
-{
-	state.fd.assign(syscalls::socket(PF_UNIX, SOCK_STREAM, 0), file, line);
-	if (state.fd == -1) {
-		int e = errno;
-		throw SystemException("Cannot create a Unix socket file descriptor", e);
-	}
-
-	state.filename = filename;
-	setNonBlocking(state.fd);
-}
-
-bool
-connectToUnixServer(NUnix_State &state) {
-	struct sockaddr_un addr;
-	int ret;
-
-	if (state.filename.size() > sizeof(addr.sun_path) - 1) {
-		string message = "Cannot connect to Unix socket '";
-		message.append(state.filename.data(), state.filename.size());
-		message.append("': filename is too long.");
-		throw RuntimeException(message);
-	}
-
-	addr.sun_family = AF_UNIX;
-	memcpy(addr.sun_path, state.filename.data(), state.filename.size());
-	addr.sun_path[state.filename.size()] = '\0';
-
-	ret = syscalls::connect(state.fd, (const sockaddr *) &addr, sizeof(addr));
-	if (ret == -1) {
-		if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
-			return false;
-		} else if (errno == EISCONN) {
-			return true;
-		} else {
-			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 {
-		return true;
-	}
-}
-
 int
 connectToTcpServer(const StaticString &hostname, unsigned int port,
 	const char *file, unsigned int line)
@@ -591,145 +477,285 @@ connectToTcpServer(const StaticString &hostname, unsigned int port,
 	return fd;
 }
 
-void
-setupNonBlockingTcpSocket(NTCP_State &state, const StaticString &hostname, int port,
-	const char *file, unsigned int line)
-{
+
+/****** Socket connection establishment (non-blocking) ******/
+
+std::pair<int, bool>
+createNonBlockingSocketConnection(const StaticString &address, const char *file, unsigned int line) {
+	TRACE_POINT();
+	switch (getSocketAddressType(address)) {
+	case SAT_UNIX:
+		return createNonBlockingUnixSocketConnection(parseUnixSocketAddress(address), file, line);
+	case SAT_TCP: {
+		string host;
+		unsigned short port;
+
+		parseTcpSocketAddress(address, host, port);
+		return createNonBlockingTcpSocketConnection(host, port, file, line);
+	}
+	default:
+		throw ArgumentException(string("Unknown address type for '") + address + "'");
+	}
+}
+
+std::pair<int, bool>
+createNonBlockingUnixSocketConnection(const StaticString &filename, const char *file, unsigned int line) {
+	struct sockaddr_un addr;
+
+	if (filename.size() > sizeof(addr.sun_path) - 1) {
+		string message = "Cannot connect to Unix socket '";
+		message.append(filename.data(), filename.size());
+		message.append("': filename is too long.");
+		throw ArgumentException(message);
+	}
+
+
+	int fd = syscalls::socket(PF_UNIX, SOCK_STREAM, 0);
+	if (fd == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a Unix socket file descriptor", e);
+	}
+
 	int ret;
+	FdGuard guard(fd, nullptr, 0);
+	P_LOG_FILE_DESCRIPTOR_OPEN4(fd, file, line, "NonBlockingUnixSocketConnection");
+	setNonBlocking(fd);
 
-	memset(&state.hints, 0, sizeof(state.hints));
-	state.hints.ai_family   = PF_UNSPEC;
-	state.hints.ai_socktype = SOCK_STREAM;
-	ret = getaddrinfo(hostname.toString().c_str(), toString(port).c_str(),
-		&state.hints, &state.res);
+	addr.sun_family = AF_UNIX;
+	memcpy(addr.sun_path, filename.data(), filename.size());
+	addr.sun_path[filename.size()] = '\0';
+
+	ret = syscalls::connect(fd, (const sockaddr *) &addr, sizeof(addr));
+	if (ret == -1) {
+		if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
+			guard.clear();
+			return std::make_pair(fd, false);
+		} else if (errno == EISCONN) {
+			guard.clear();
+			return std::make_pair(fd, true);
+		} else {
+			int e = errno;
+			string message = "Cannot connect to Unix socket '";
+			message.append(filename.data(), filename.size());
+			message.append("'");
+			throw SystemException(message, e);
+		}
+	} else {
+		guard.clear();
+		return std::make_pair(fd, true);
+	}
+}
+
+std::pair<int, bool>
+createNonBlockingTcpSocketConnection(const StaticString &hostname, unsigned int port, const char *file, unsigned int line) {
+	const string hostnameCopy = string(hostname.data(), hostname.size());
+	const string portString = toString(port);
+	struct addrinfo hints, *res;
+	int ret;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family   = PF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	ret = getaddrinfo(hostnameCopy.c_str(), portString.c_str(),
+		&hints, &res);
 	if (ret != 0) {
 		string message = "Cannot resolve IP address '";
 		message.append(hostname.data(), hostname.size());
 		message.append(":");
-		message.append(toString(port));
+		message.append(portString);
 		message.append("': ");
 		message.append(gai_strerror(ret));
 		throw IOException(message);
 	}
 
-	state.fd.assign(syscalls::socket(PF_INET, SOCK_STREAM, 0), file, line);
-	if (state.fd == -1) {
+
+	int fd = syscalls::socket(PF_INET, SOCK_STREAM, 0);
+	if (fd == -1) {
 		int e = errno;
 		throw SystemException("Cannot create a TCP socket file descriptor", e);
 	}
 
-	state.hostname = hostname;
-	state.port = port;
-	setNonBlocking(state.fd);
-}
+	FdGuard guard(fd, nullptr, 0);
+	P_LOG_FILE_DESCRIPTOR_OPEN4(fd, file, line, "NonBlockingTcpSocketConnection");
+	setNonBlocking(fd);
 
-bool
-connectToTcpServer(NTCP_State &state) {
-	int ret;
 
-	ret = syscalls::connect(state.fd, state.res->ai_addr, state.res->ai_addrlen);
+	ret = syscalls::connect(fd, res->ai_addr, res->ai_addrlen);
 	if (ret == -1) {
 		if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
-			return false;
+			guard.clear();
+			return make_pair(fd, false);
 		} else if (errno == EISCONN) {
-			freeaddrinfo(state.res);
-			state.res = NULL;
-			return true;
+			freeaddrinfo(res);
+			guard.clear();
+			return make_pair(fd, true);
 		} else {
 			int e = errno;
 			string message = "Cannot connect to TCP socket '";
-			message.append(state.hostname);
+			message.append(hostname);
 			message.append(":");
-			message.append(toString(state.port));
+			message.append(portString);
 			message.append("'");
 			throw SystemException(message, e);
 		}
 	} else {
-		freeaddrinfo(state.res);
-		state.res = NULL;
-		return true;
+		freeaddrinfo(res);
+		guard.clear();
+		return make_pair(fd, true);
 	}
 }
 
-NConnect_State::NConnect_State(const StaticString &address, const char *file, unsigned int line)
+
+/****** Scope guards ******/
+
+FdGuard::FdGuard(FdGuard &&other)
+	: mFd(other.mFd)
 {
-	TRACE_POINT();
-	type = getSocketAddressType(address);
-	switch (type) {
-	case SAT_UNIX:
-		setupNonBlockingUnixSocket(s_unix, parseUnixSocketAddress(address),
-			file, line);
-		break;
-	case SAT_TCP: {
-		string host;
-		unsigned short port;
+	other.mFd = -1;
+}
 
-		parseTcpSocketAddress(address, host, port);
-		setupNonBlockingTcpSocket(s_tcp, host, port, file, line);
-		break;
+FdGuard::FdGuard(int fd, const char *sourceFile, unsigned int sourceLine)
+	: mFd(fd)
+{
+	if (mFd != -1 && sourceFile != nullptr) {
+		P_LOG_FILE_DESCRIPTOR_OPEN3(fd, sourceFile, sourceLine);
 	}
-	default:
-		throw ArgumentException(string("Unknown address type for '") + address + "'");
+}
+
+FdGuard::~FdGuard() noexcept(false) {
+	if (mFd != -1) {
+		try {
+			safelyClose(mFd);
+		} catch (const std::exception &e) {
+			bool uncaughtException =
+				#if __cplusplus >= 201703L
+					std::uncaught_exceptions() > 0;
+				#else
+					std::uncaught_exception();
+				#endif
+			if (uncaughtException) {
+				P_WARN("Error closing file descriptor " << mFd << ": " << e.what());
+				return;
+			} else {
+				throw e;
+			}
+		}
+		P_LOG_FILE_DESCRIPTOR_CLOSE(mFd);
 	}
 }
 
-bool
-NConnect_State::connectToServer() {
-	switch (type) {
-	case SAT_UNIX:
-		return connectToUnixServer(s_unix);
-	case SAT_TCP:
-		return connectToTcpServer(s_tcp);
-	default:
-		throw RuntimeException("Unknown address type");
+FdGuard &
+FdGuard::operator=(FdGuard &&other) {
+	if (this != &other) {
+		if (mFd != -1) {
+			safelyClose(mFd);
+			P_LOG_FILE_DESCRIPTOR_CLOSE(mFd);
+		}
+		mFd = other.mFd;
+		other.mFd = -1;
 	}
+	return *this;
 }
 
-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");
+void
+FdGuard::clear() noexcept {
+	mFd = -1;
+}
+
+void
+FdGuard::runNow() noexcept(false) {
+	if (mFd != -1) {
+		safelyClose(mFd);
+		P_LOG_FILE_DESCRIPTOR_CLOSE(mFd);
+		mFd = -1;
 	}
 }
 
-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;
+
+/****** Other ******/
+
+bool
+purgeStdio(FILE *f) {
+	#if defined(HAVE_FPURGE)
+		fpurge(f);
+		return true;
+	#elif defined(HAVE___FPURGE)
+		__fpurge(f);
+		return true;
+	#else
+		return false;
+	#endif
 }
 
-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;
+void
+setBlocking(int fd) {
+	int flags, ret;
+
+	do {
+		flags = fcntl(fd, F_GETFL);
+	} while (flags == -1 && errno == EINTR);
+	if (flags == -1) {
+		int e = errno;
+		throw SystemException("Cannot set socket to blocking mode: "
+			"cannot get socket flags",
+			e);
+	}
+	do {
+		ret = fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
+	} while (ret == -1 && errno == EINTR);
+	if (ret == -1) {
+		int e = errno;
+		throw SystemException("Cannot set socket to blocking mode: "
+			"cannot set socket flags",
+			e);
+	}
+}
+
+void
+setNonBlocking(int fd) {
+	int flags, ret;
+
+	do {
+		flags = fcntl(fd, F_GETFL);
+	} while (flags == -1 && errno == EINTR);
+	if (flags == -1) {
+		int e = errno;
+		throw SystemException("Cannot set socket to non-blocking mode: "
+			"cannot get socket flags",
+			e);
+	}
+	do {
+		ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+	} while (ret == -1 && errno == EINTR);
+	if (ret == -1) {
+		int e = errno;
+		throw SystemException("Cannot set socket to non-blocking mode: "
+			"cannot set socket flags",
+			e);
+	}
+}
+
+int
+callAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options) {
+	#if defined(HAVE_ACCEPT4)
+		int ret;
+		do {
+			ret = ::accept4(sock, addr, addr_len, options);
+		} while (ret == -1 && errno == EINTR);
+		return ret;
+	#else
+		errno = ENOSYS;
+		return -1;
+	#endif
 }
 
 bool
 pingTcpServer(const StaticString &host, unsigned int port, unsigned long long *timeout) {
 	TRACE_POINT();
-	NTCP_State state;
-
-	setupNonBlockingTcpSocket(state, host, port, __FILE__, __LINE__);
+	std::pair<int, bool> nbcResult;
 
 	try {
-		if (connectToTcpServer(state)) {
-			return true;
-		}
+		nbcResult = createNonBlockingTcpSocketConnection(host, port, __FILE__, __LINE__);
 	} catch (const SystemException &e) {
 		if (e.code() == ECONNREFUSED) {
 			return false;
@@ -737,13 +763,17 @@ pingTcpServer(const StaticString &host, unsigned int port, unsigned long long *t
 			throw e;
 		}
 	}
+	FdGuard guard(nbcResult.first, nullptr, 0);
+	if (nbcResult.second) {
+		return true;
+	}
 
 	// Cannot connect to the port yet, but that may not mean the
 	// port is unavailable. So poll the socket.
 
 	bool connectable;
 	try {
-		connectable = waitUntilWritable(state.fd, timeout);
+		connectable = waitUntilWritable(nbcResult.first, timeout);
 	} catch (const SystemException &e) {
 		throw SystemException("Error polling TCP socket "
 			+ host + ":" + toString(port), e.code());
@@ -753,24 +783,21 @@ pingTcpServer(const StaticString &host, unsigned int port, unsigned long long *t
 		return false;
 	}
 
-	// Try to connect the socket one last time.
+	// Now check the final connection establishment status.
 
-	try {
-		return connectToTcpServer(state);
-	} catch (const SystemException &e) {
-		if (e.code() == ECONNREFUSED) {
-			return false;
-		} else if (e.code() == EISCONN || e.code() == EINVAL) {
-			#ifdef __FreeBSD__
-				// Work around bug in FreeBSD (discovered on
-				// January 20 2013 in daemon_controller)
-				return false;
-			#else
-				throw e;
-			#endif
-		} else {
-			throw e;
-		}
+	int connectError = 0;
+	socklen_t connectErrorLen = sizeof(connectError);
+	if (getsockopt(nbcResult.first, SOL_SOCKET, SO_ERROR, &connectError, &connectErrorLen) == -1) {
+		throw SystemException("Error checking TCP socket " + host + ":" + toString(port)
+			+ " connection establishment status", connectError);
+	}
+	if (connectError == 0) {
+		return true;
+	} else if (connectError == ECONNREFUSED) {
+		return false;
+	} else {
+		throw SystemException("Error connecting to TCP socket " + host + ":"
+			+ toString(port), connectError);
 	}
 }