passenger 2.2.15 → 3.0.0.pre1

data/ext/common/Utils/ScopeGuard.h

@@ -0,0 +1,72 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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_SCOPE_GUARD_H_
+#define _PASSENGER_SCOPE_GUARD_H_
+
+#include <boost/noncopyable.hpp>
+#include <boost/function.hpp>
+
+namespace Passenger {
+
+using namespace boost;
+
+
+/**
+ * Guard object for making sure that a certain function is going to be
+ * called when the object goes out of scope. To avoid the function from
+ * being called, call clear().
+ */
+class ScopeGuard: public noncopyable {
+private:
+	function<void ()> func;
+	
+public:
+	ScopeGuard() { }
+	
+	ScopeGuard(const function<void ()> &func) {
+		this->func = func;
+	}
+	
+	~ScopeGuard() {
+		if (func) {
+			func();
+		}
+	}
+	
+	void clear() {
+		func = function<void()>();
+	}
+	
+	void runNow() {
+		function<void ()> oldFunc = func;
+		func = function<void()>();
+		oldFunc();
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SCOPE_GUARD_H_ */

data/ext/common/Utils/StrIntUtils.cpp

@@ -0,0 +1,329 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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.
+ */
+#include "Exceptions.h"
+#include "StrIntUtils.h"
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+
+namespace Passenger {
+
+string
+fillInMiddle(unsigned int max, const string &prefix, const string &middle, const string &postfix) {
+	if (max <= prefix.size() + postfix.size()) {
+		throw ArgumentException("Impossible to build string with the given size constraint.");
+	}
+	
+	unsigned int fillSize = max - (prefix.size() + postfix.size());
+	if (fillSize > middle.size()) {
+		return prefix + middle + postfix;
+	} else {
+		return prefix + middle.substr(0, fillSize) + postfix;
+	}
+}
+
+bool
+startsWith(const StaticString &str, const StaticString &substr) {
+	if (str.size() >= substr.size()) {
+		return memcmp(str.c_str(), substr.c_str(), substr.size()) == 0;
+	} else {
+		return false;
+	}
+}
+
+string
+toLowerCase(const StaticString &str) {
+	string result(str.size(), '\0');
+	for (string::size_type i = 0; i < str.size(); i++) {
+		result[i] = tolower(str[i]);
+	}
+	return result;
+}
+
+void
+split(const string &str, char sep, vector<string> &output) {
+	string::size_type start, pos;
+	start = 0;
+	output.clear();
+	while ((pos = str.find(sep, start)) != string::npos) {
+		output.push_back(str.substr(start, pos - start));
+		start = pos + 1;
+	}
+	output.push_back(str.substr(start));
+}
+
+string toString(const vector<string> &vec) {
+	vector<StaticString> vec2;
+	vec2.reserve(vec.size());
+	for (vector<string>::const_iterator it = vec.begin(); it != vec.end(); it++) {
+		vec2.push_back(*it);
+	}
+	return toString(vec2);
+}
+
+string toString(const vector<StaticString> &vec) {
+	string result = "[";
+	vector<StaticString>::const_iterator it;
+	unsigned int i;
+	for (it = vec.begin(), i = 0; it != vec.end(); it++, i++) {
+		result.append("'");
+		result.append(it->data(), it->size());
+		if (i == vec.size() - 1) {
+			result.append("'");
+		} else {
+			result.append("', ");
+		}
+	}
+	result.append("]");
+	return result;
+}
+
+string
+pointerToIntString(void *pointer) {
+	// Use wierd union construction to avoid compiler warnings.
+	if (sizeof(void *) == sizeof(unsigned int)) {
+		union {
+			void *pointer;
+			unsigned int value;
+		} u;
+		u.pointer = pointer;
+		return toString(u.value);
+	} else if (sizeof(void *) == sizeof(unsigned long long)) {
+		union {
+			void *pointer;
+			unsigned long long value;
+		} u;
+		u.pointer = pointer;
+		return toString(u.value);
+	} else {
+		fprintf(stderr, "Pointer size unsupported...\n");
+		abort();
+	}
+}
+
+unsigned long long
+stringToULL(const StaticString &str) {
+	unsigned long long result = 0;
+	string::size_type i = 0;
+	const char *data = str.data();
+	
+	while (data[i] == ' ' && i < str.size()) {
+		i++;
+	}
+	while (data[i] >= '0' && data[i] <= '9' && i < str.size()) {
+		result *= 10;
+		result += data[i] - '0';
+		i++;
+	}
+	return result;
+}
+
+long long
+stringToLL(const StaticString &str) {
+	long long result = 0;
+	string::size_type i = 0;
+	const char *data = str.data();
+	bool minus = false;
+	
+	while (data[i] == ' ' && i < str.size()) {
+		i++;
+	}
+	if (data[i] == '-') {
+		minus = true;
+		i++;
+	}
+	while (data[i] >= '0' && data[i] <= '9' && i < str.size()) {
+		result *= 10;
+		result += data[i] - '0';
+		i++;
+	}
+	if (minus) {
+		return -result;
+	} else {
+		return result;
+	}
+}
+
+unsigned long long
+hexToULL(const StaticString &hex) {
+	unsigned long long result = 0;
+	string::size_type i = 0;
+	bool done = false;
+	
+	while (i < hex.size() && !done) {
+		char c = hex[i];
+		if (c >= '0' && c <= '9') {
+			result *= 16;
+			result += c - '0';
+		} else if (c >= 'a' && c <= 'f') {
+			result *= 16;
+			result += 10 + (c - 'a');
+		} else if (c >= 'A' && c <= 'F') {
+			result *= 16;
+			result += 10 + (c - 'A');
+		} else {
+			done = true;
+		}
+		i++;
+	}
+	return result;
+}
+
+unsigned long long
+hexatriToULL(const StaticString &str) {
+	unsigned long long result = 0;
+	string::size_type i = 0;
+	bool done = false;
+	
+	while (i < str.size() && !done) {
+		char c = str[i];
+		if (c >= '0' && c <= '9') {
+			result *= 36;
+			result += c - '0';
+		} else if (c >= 'a' && c <= 'z') {
+			result *= 36;
+			result += 10 + (c - 'a');
+		} else if (c >= 'A' && c <= 'Z') {
+			result *= 36;
+			result += 10 + (c - 'A');
+		} else {
+			done = true;
+		}
+		i++;
+	}
+	return result;
+}
+
+string
+toHex(const StaticString &data) {
+	string result(data.size() * 2, '\0');
+	toHex(data, (char *) result.data());
+	return result;
+}
+
+static const char hex_chars[] = {
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+	'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+	'u', 'v', 'w', 'x', 'y', 'z'
+};
+
+static const char upcase_hex_chars[] = {
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+	'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+	'U', 'V', 'W', 'X', 'Y', 'Z'
+};
+
+void
+toHex(const StaticString &data, char *output, bool upperCase) {
+	const char *data_buf = data.c_str();
+	string::size_type i;
+	
+	if (upperCase) {
+		for (i = 0; i < data.size(); i++) {
+			output[i * 2] = upcase_hex_chars[(unsigned char) data_buf[i] / 16];
+			output[i * 2 + 1] = upcase_hex_chars[(unsigned char) data_buf[i] % 16];
+		}
+	} else {
+		for (i = 0; i < data.size(); i++) {
+			output[i * 2] = hex_chars[(unsigned char) data_buf[i] / 16];
+			output[i * 2 + 1] = hex_chars[(unsigned char) data_buf[i] % 16];
+		}
+	}
+}
+
+string
+integerToHex(long long value) {
+	char buf[sizeof(long long) * 2 + 1];
+	integerToHex(value, buf);
+	return string(buf);
+}
+
+string
+integerToHexatri(long long value) {
+	char buf[sizeof(long long) * 2 + 1];
+	integerToHexatri(value, buf);
+	return string(buf);
+}
+
+int
+atoi(const string &s) {
+	return ::atoi(s.c_str());
+}
+
+long
+atol(const string &s) {
+	return ::atol(s.c_str());
+}
+
+string
+cEscapeString(const StaticString &input) {
+	string result;
+	const char *current = input.c_str();
+	const char *end = current + input.size();
+	
+	result.reserve(input.size());
+	while (current < end) {
+		char c = *current;
+		if (c >= 32 && c <= 126) {
+			// Printable ASCII.
+			result.append(1, c);
+		} else {
+			char buf[sizeof("\\xFF")];
+			
+			switch (c) {
+			case '\0':
+				// Explicitly in hex format in order to avoid confusion
+				// with any '0' characters that come after this byte.
+				result.append("\\x00");
+				break;
+			case '\t':
+				result.append("\\t");
+				break;
+			case '\n':
+				result.append("\\n");
+				break;
+			case '\r':
+				result.append("\\r");
+				break;
+			case '\e':
+				result.append("\\e");
+				break;
+			default:
+				buf[0] = '\\';
+				buf[1] = 'x';
+				toHex(StaticString(current, 1), buf + 2, true);
+				buf[4] = '\0';
+				result.append(buf, sizeof(buf) - 1);
+				break;
+			}
+		}
+		current++;
+	}
+	return result;
+}
+
+} // namespace Passenger

data/ext/common/Utils/StrIntUtils.h

@@ -0,0 +1,228 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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_STR_INT_UTILS_H_
+#define _PASSENGER_STR_INT_UTILS_H_
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include "StaticString.h"
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * Given a prefix string, a middle string and a postfix string, try to build a string
+ * that looks like <tt>prefix + middle + postfix</tt>, with as many characters from
+ * <tt>midle</tt> preserved as possible.
+ *
+ * If <tt>prefix + middle + postfix</tt> does not fit in <tt>max</tt> characters,
+ * then <tt>middle</tt> will be truncated so that it fits. If <tt>max</tt> is too
+ * small to contain even 1 character from <tt>middle</tt>, then an ArgumentException
+ * will be thrown.
+ *
+ * @code
+ *   fillInMiddle(18, "server.", "1234", ".socket");    // "server.1234.socket"
+ *   fillInMiddle(16, "server.", "1234", ".socket");    // "server.12.socket"
+ *   fillInMiddle(14, "server.", "1234", ".socket");    // ArgumentException
+ * @endcode
+ *
+ * @returns The resulting string, with <tt>middle</tt> possibly truncated.
+ * @throws ArgumentException <tt>max</tt> is too small to contain even 1
+ *         character from <tt>middle</tt>.
+ * @post result.size() <= max
+ */
+string fillInMiddle(unsigned int max, const string &prefix, const string &middle,
+	const string &postfix = "");
+
+/**
+ * Checks whether <tt>str</tt> starts with <tt>substr</tt>.
+ */
+bool startsWith(const StaticString &str, const StaticString &substr);
+
+/**
+ * Converts the string to lowercase.
+ */
+string toLowerCase(const StaticString &str);
+
+/**
+ * Split the given string using the given separator.
+ *
+ * @param str The string to split.
+ * @param sep The separator to use.
+ * @param output The vector to write the output to.
+ */
+void split(const string &str, char sep, vector<string> &output);
+
+/**
+ * Convert anything to a string.
+ */
+template<typename T> string
+toString(T something) {
+	stringstream s;
+	s << something;
+	return s.str();
+}
+
+string toString(const vector<string> &vec);
+string toString(const vector<StaticString> &vec);
+
+string pointerToIntString(void *pointer);
+
+/**
+ * Converts the given integer string to an unsigned long long integer.
+ */
+unsigned long long stringToULL(const StaticString &str);
+
+/**
+ * Converts the given integer string to a long long integer.
+ */
+long long stringToLL(const StaticString &str);
+
+/**
+ * Converts the given hexadecimal string to an unsigned long long integer.
+ */
+unsigned long long hexToULL(const StaticString &str);
+
+/**
+ * Converts the given hexatridecimal (base 36) string to an unsigned long long integer.
+ */
+unsigned long long hexatriToULL(const StaticString &str);
+
+/**
+ * Convert the given binary data to hexadecimal.
+ */
+string toHex(const StaticString &data);
+
+/**
+ * Convert the given binary data to hexadecimal. This form accepts an
+ * output buffer which must be at least <tt>data.size() * 2</tt> bytes large.
+ */
+void toHex(const StaticString &data, char *output, bool upperCase = false);
+
+/**
+ * Convert the given integer to some other radix, placing
+ * the result into the given output buffer. This buffer must be at
+ * least <tt>2 * sizeof(IntegerType) + 1</tt> bytes. The output buffer
+ * will be NULL terminated. Supported radices are 2-36.
+ *
+ * @return The size of the created string, excluding
+ *         terminating NULL.
+ */
+template<typename IntegerType, int radix>
+unsigned int
+integerToOtherBase(IntegerType value, char *output) {
+	static const char hex_chars[] = {
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+		'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+		'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+		'u', 'v', 'w', 'x', 'y', 'z'
+	};
+	char buf[sizeof(value) * 2];
+	IntegerType remainder = value;
+	unsigned int size = 0;
+	
+	do {
+		buf[size] = hex_chars[remainder % radix];
+		remainder = remainder / radix;
+		size++;
+	} while (remainder != 0);
+	
+	for (unsigned int i = 0; i < size; i++) {
+		output[size - i - 1] = buf[i];
+	}
+	output[size] = '\0';
+	return size;
+}
+
+/**
+ * Convert the given integer to hexadecimal, placing the result
+ * into the given output buffer. This buffer must be at least
+ * <tt>2 * sizeof(IntegerType) + 1</tt> bytes. The output buffer
+ * will be NULL terminated.
+ *
+ * @return The size of the created hexadecimal string, excluding
+ *         terminating NULL.
+ */
+template<typename IntegerType>
+unsigned int
+integerToHex(IntegerType value, char *output) {
+	return integerToOtherBase<IntegerType, 16>(value, output);
+}
+
+/**
+ * Convert the given integer to a hexadecimal string.
+ */
+string integerToHex(long long value);
+
+/**
+ * Convert the given integer to hexatridecimal (Base 36), placing the
+ * result into the given output buffer. This buffer must be at least
+ * <tt>2 * sizeof(IntegerType) + 1</tt> bytes. The output buffer
+ * will be NULL terminated.
+ *
+ * @return The size of the created hexatridecimal string, excluding
+ *         terminating NULL.
+ */
+template<typename IntegerType>
+unsigned int
+integerToHexatri(IntegerType value, char *output) {
+	return integerToOtherBase<IntegerType, 36>(value, output);
+}
+
+/**
+ * Convert the given integer to a hexatridecimal string.
+ */
+string integerToHexatri(long long value);
+
+/**
+ * Converts the given string to an integer.
+ */
+int atoi(const string &s);
+
+/**
+ * Converts the given string to a long integer.
+ */
+long atol(const string &s);
+
+/**
+ * Round <em>number</em> up to the nearest multiple of <em>multiple</em>.
+ */
+template<typename IntegerType>
+IntegerType
+roundUp(IntegerType number, IntegerType multiple) {
+	return (number + multiple - 1) / multiple * multiple;
+}
+
+/**
+ * Escape non-ASCII-printable characters in the given string with C-style escape sequences,
+ * e.g. "foo\nbar\0" becomes "foo\\nbar\\0".
+ */
+string cEscapeString(const StaticString &input);
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_STR_INT_UTILS_H_ */