passenger-jmazzi 2.2.9

data/ext/common/ApplicationPoolStatusReporter.h

@@ -0,0 +1,336 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2008, 2009 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_APPLICATION_POOL_STATUS_REPORTER_H_
+#define _PASSENGER_APPLICATION_POOL_STATUS_REPORTER_H_
+
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#include <oxt/thread.hpp>
+#include <oxt/backtrace.hpp>
+#include <oxt/system_calls.hpp>
+
+#include <string>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <cstdio>
+#include <unistd.h>
+#include <errno.h>
+
+#include "StandardApplicationPool.h"
+#include "MessageChannel.h"
+#include "Exceptions.h"
+#include "Logging.h"
+#include "Utils.h"
+
+namespace Passenger {
+
+using namespace boost;
+using namespace oxt;
+using namespace std;
+
+/**
+ * An ApplicationPoolStatusReporter allows commandline admin tools to inspect
+ * the status of a StandardApplicationPool. It does so by creating a Unix socket
+ * in the Passenger temp folder, which tools can connect to to query for
+ * information.
+ *
+ * An ApplicationPoolStatusReporter creates a background thread for handling
+ * connections on the socket. This thread will be automatically cleaned up upon
+ * destroying the ApplicationPoolStatusReporter object.
+ */
+class ApplicationPoolStatusReporter {
+private:
+	/**
+	 * Wrapper class around a file descriptor integer, for RAII behavior.
+	 *
+	 * A FileDescriptor object behaves just like an int, so that you can pass it to
+	 * system calls such as read(). It performs reference counting. When the last
+	 * copy of a FileDescriptor has been destroyed, the underlying file descriptor
+	 * will be automatically closed.
+	 */
+	class FileDescriptor {
+	private:
+		struct SharedData {
+			int fd;
+
+			/**
+			 * Constructor to assign this file descriptor's handle.
+			 */
+			SharedData(int fd) {
+				this->fd = fd;
+			}
+
+			/**
+			 * Attempts to close this file descriptor. When created on the stack,
+			 * this destructor will automatically be invoked as a result of C++
+			 * semantics when exiting the scope this object was created in. This
+			 * ensures that stack created objects with destructors like these will
+			 * de-allocate their resources upon leaving their corresponding scope.
+			 * This pattern is also known Resource Acquisition Is Initialization (RAII).
+			 *
+			 * @throws SystemException File descriptor could not be closed.
+			 */
+			~SharedData() {
+				this_thread::disable_syscall_interruption dsi;
+				if (syscalls::close(fd) == -1) {
+					throw SystemException("Cannot close file descriptor", errno);
+				}
+			}
+		};
+
+		/* Shared pointer for reference counting on this file descriptor */
+		shared_ptr<SharedData> data;
+
+	public:
+		FileDescriptor() {
+			// Do nothing.
+		}
+
+		/**
+		 * Creates a new FileDescriptor instance with the given fd as a handle.
+		 */
+		FileDescriptor(int fd) {
+			data = ptr(new SharedData(fd));
+		}
+
+		/**
+		 * Overloads the integer cast operator so that it will return the file
+		 * descriptor handle as an integer.
+		 *
+		 * @return This file descriptor's handle as an integer.
+		 */
+		operator int () const {
+			return data->fd;
+		}
+	};
+	
+	/** The application pool to monitor. */
+	StandardApplicationPoolPtr pool;
+	
+	/** The socket's filename. */
+	char filename[PATH_MAX];
+	
+	/** The socket's file descriptor. */
+	int serverFd;
+	
+	/** The main thread. */
+	oxt::thread *mainThread;
+	
+	/** The mutex which protects the 'threads' member. */
+	boost::mutex threadsLock;
+	
+	/** A map which maps a client file descriptor to its handling thread. */
+	map< int, shared_ptr<oxt::thread> > threads;
+	
+	void writeScalarAndIgnoreErrors(MessageChannel &channel, const string &data) {
+		try {
+			channel.writeScalar(data);
+		} catch (const SystemException &e) {
+			// Don't care about write errors.
+		}
+	}
+	
+	void mainThreadFunction() {
+		TRACE_POINT();
+		try {
+			while (!this_thread::interruption_requested()) {
+				UPDATE_TRACE_POINT();
+				sockaddr_un addr;
+				socklen_t addr_len = sizeof(addr);
+				
+				FileDescriptor fd(syscalls::accept(serverFd, (struct sockaddr *) &addr, &addr_len));
+				if (fd == -1) {
+					int e = errno;
+					P_ERROR("Cannot accept new client on status reporter socket: " <<
+						strerror(e) << " (" << e << ")");
+					break;
+				}
+				
+				boost::lock_guard<boost::mutex> l(threadsLock);
+				this_thread::disable_syscall_interruption dsi;
+				this_thread::disable_interruption di;
+				shared_ptr<oxt::thread> thread(new oxt::thread(
+					bind(&ApplicationPoolStatusReporter::clientThreadFunction, this, fd),
+					"Status reporter client thread " + toString(fd),
+					1024 * 128
+				));
+				threads[fd] = thread;
+			}
+		} catch (const boost::thread_interrupted &) {
+			P_TRACE(2, "Status reporter main thread interrupted.");
+		} catch (const exception &e) {
+			P_ERROR("Error in status reporter main thread: " << e.what());
+		}
+	}
+	
+	void clientThreadFunction(FileDescriptor fd) {
+		TRACE_POINT();
+		MessageChannel channel(fd);
+		
+		try {
+			while (!this_thread::interruption_requested()) {
+				vector<string> args;
+				
+				UPDATE_TRACE_POINT();
+				if (!channel.read(args) || args.size() < 1) {
+					break;
+				}
+				
+				if (args[0] == "backtraces") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, oxt::thread::all_backtraces());
+				} else if (args[0] == "status") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, pool->toString());
+				} else if (args[0] == "status_xml") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, pool->toXml());
+				} else {
+					P_ERROR("Error in status reporter client thread: unknown query '" <<
+						args[0] << "'.");
+				}
+			}
+		} catch (const boost::thread_interrupted &) {
+			P_TRACE(2, "Status reporter client thread " << fd << " interrupted.");
+		} catch (const exception &e) {
+			P_ERROR("Error in status reporter client thread: " << e.what());
+		}
+		
+		boost::lock_guard<boost::mutex> l(threadsLock);
+		this_thread::disable_syscall_interruption dsi;
+		this_thread::disable_interruption di;
+		threads.erase(fd);
+	}
+
+public:
+	/**
+	 * Creates a new ApplicationPoolStatusReporter.
+	 *
+	 * @param pool The application pool to monitor.
+	 * @param userSwitching Whether user switching is enabled. This is used
+	 *                      for determining the optimal permissions for the
+	 *                      FIFO file and the temp directory that might get
+	 *                      created.
+	 * @param permissions The permissions with which the FIFO should
+	 *                    be created.
+	 * @param uid The UID of the user who should own the FIFO file, or
+	 *            -1 if the current user should be set as owner.
+	 * @param gid The GID of the user who should own the FIFO file, or
+	 *            -1 if the current group should be set as group.
+	 * @throws RuntimeException An error occurred.
+	 * @throws SystemException An error occurred while creating the server socket.
+	 * @throws boost::thread_resource_error Something went wrong during
+	 *     creation of the thread.
+	 * @throws boost::thread_interrupted A system call has been interrupted.
+	 */
+	ApplicationPoolStatusReporter(StandardApplicationPoolPtr &pool,
+	                              bool userSwitching,
+	                              mode_t permissions = S_IRUSR | S_IWUSR,
+	                              uid_t uid = -1, gid_t gid = -1) {
+		int ret;
+		
+		this->pool = pool;
+		
+		createPassengerTempDir(getSystemTempDir(), userSwitching,
+			"nobody", geteuid(), getegid());
+		
+		snprintf(filename, sizeof(filename) - 1, "%s/info/status.socket",
+			getPassengerTempDir().c_str());
+		filename[PATH_MAX - 1] = '\0';
+		serverFd = createUnixServer(filename, 10);
+		
+		/* Set the socket file's permissions... */
+		do {
+			ret = chmod(filename, permissions);
+		} while (ret == -1 && errno == EINTR);
+		
+		/* ...and ownership. */
+		if (uid != (uid_t) -1 && gid != (gid_t) -1) {
+			do {
+				ret = chown(filename, uid, gid);
+			} while (ret == -1 && errno == EINTR);
+			if (errno == -1) {
+				int e = errno;
+				char message[1024];
+				
+				snprintf(message, sizeof(message) - 1,
+					"Cannot set the owner for socket file '%s' to %lld and its group to %lld",
+					filename, (long long) uid, (long long) gid);
+				message[sizeof(message) - 1] = '\0';
+				do {
+					ret = close(serverFd);
+				} while (ret == -1 && errno == EINTR);
+				throw SystemException(message, e);
+			}
+		}
+		
+		try {
+			mainThread = new oxt::thread(
+				bind(&ApplicationPoolStatusReporter::mainThreadFunction, this),
+				"Status reporter main thread",
+				1024 * 128
+			);
+		} catch (...) {
+			do {
+				ret = close(serverFd);
+			} while (ret == -1 && errno == EINTR);
+			throw;
+		}
+	}
+	
+	~ApplicationPoolStatusReporter() {
+		this_thread::disable_syscall_interruption dsi;
+		this_thread::disable_interruption di;
+		int ret;
+		
+		do {
+			ret = unlink(filename);
+		} while (ret == -1 && errno == EINTR);
+		
+		mainThread->interrupt_and_join();
+		delete mainThread;
+		
+		do {
+			ret = close(serverFd);
+		} while (ret == -1 && errno == EINTR);
+		
+		/* We make a copy of the data structure here to avoid deadlocks. */
+		map< int, shared_ptr<oxt::thread> > threadsCopy;
+		{
+			boost::lock_guard<boost::mutex> l(threadsLock);
+			threadsCopy = threads;
+		}
+		map< int, shared_ptr<oxt::thread> >::iterator it;
+		for (it = threadsCopy.begin(); it != threadsCopy.end(); it++) {
+			it->second->interrupt_and_join();
+		}
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL_STATUS_REPORTER_H_ */

data/ext/common/Base64.cpp

@@ -0,0 +1,143 @@
+/*
+ * Base64 encoding and decoding routines
+ *
+ * Copyright (C) 2004-2008 René Nyffenegger
+ * Modified by Phusion for inclusion in Phusion Passenger.
+ *
+ * This source code is provided 'as-is', without any express or implied
+ * warranty. In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented; you must not
+ *    claim that you wrote the original source code. If you use this source code
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original source code.
+ *
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+ *
+ */
+
+#include <ctype.h>
+#include "Base64.h"
+
+namespace Passenger {
+
+static const std::string base64_chars = 
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789+/";
+
+
+static inline bool
+is_base64(unsigned char c) {
+	return isalnum(c) || c == '+' || c == '/';
+}
+
+string
+Base64::encode(const unsigned char *bytes_to_encode, unsigned int in_len) {
+	std::string ret;
+	int i = 0;
+	int j = 0;
+	unsigned char char_array_3[3];
+	unsigned char char_array_4[4];
+
+	// According to Wikipedia, base64-encoded data is usually 137%
+	// + 814 bytes larger than the original. Here we reserve a little
+	// more than that to avoid memory reallocations.
+	ret.reserve((std::string::size_type) (in_len * 1.37) + 1024);
+	
+	while (in_len--) {
+		char_array_3[i++] = *(bytes_to_encode++);
+		if (i == 3) {
+			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+			char_array_4[3] = char_array_3[2] & 0x3f;
+
+			for(i = 0; i < 4; i++) {
+				ret += base64_chars[char_array_4[i]];
+			}
+			i = 0;
+		}
+	}
+
+	if (i) {
+		for(j = i; j < 3; j++)
+			char_array_3[j] = '\0';
+
+		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+		char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+		char_array_4[3] = char_array_3[2] & 0x3f;
+
+		for (j = 0; (j < i + 1); j++)
+			ret += base64_chars[char_array_4[j]];
+
+		while((i++ < 3))
+			ret += '=';
+	}
+
+	return ret;
+}
+
+std::string
+Base64::decode(const unsigned char *base64_data, unsigned int in_len) {
+	int i = 0;
+	int j = 0;
+	int in_ = 0;
+	unsigned char char_array_4[4], char_array_3[3];
+	std::string ret;
+	unsigned int reserved_size;
+
+	// The decoded data should be about this large.
+	if (in_len > 814) {
+		reserved_size = (unsigned int) ((in_len - 814) / 137.0) * 100;
+	} else {
+		reserved_size = in_len;
+	}
+	ret.reserve(reserved_size);
+	
+	while (in_len-- && ( base64_data[in_] != '=') && is_base64(base64_data[in_])) {
+		char_array_4[i++] = base64_data[in_]; in_++;
+		if (i == 4) {
+			for (i = 0; i <4; i++)
+				char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+			for (i = 0; i < 3; i++)
+				ret += char_array_3[i];
+			i = 0;
+		}
+	}
+
+	if (i) {
+		for (j = i; j <4; j++)
+			char_array_4[j] = 0;
+
+		for (j = 0; j <4; j++)
+			char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+		for (j = 0; (j < i - 1); j++)
+			ret += char_array_3[j];
+	}
+
+	return ret;
+}
+
+} // namespace Passenger