colouringcode-passenger 0.1

data/ext/oxt/system_calls.hpp

@@ -0,0 +1,243 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 _OXT_SYSTEM_CALLS_HPP_
+#define _OXT_SYSTEM_CALLS_HPP_
+
+#include <boost/thread/tss.hpp>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <signal.h>
+#include <cstdio>
+#include <ctime>
+#include <cassert>
+
+/**
+ * Support for interruption of blocking system calls and C library calls
+ *
+ * This file provides a framework for writing multithreading code that can
+ * be interrupted, even when blocked on system calls or C library calls.
+ *
+ * One must first call oxt::setup_syscall_interruption_support().
+ * Then one may use the functions in oxt::syscalls as drop-in replacements
+ * for system calls or C library functions. These functions throw
+ * boost::thread_interrupted upon interruption, instead of returning an EINTR
+ * error.
+ *
+ * Once setup_syscall_interruption_support() has been called, system call
+ * interruption is enabled by default. You can enable or disable system call
+ * interruption in the current scope by creating instances of
+ * boost::this_thread::enable_syscall_interruption or
+ * boost::this_thread::disable_syscall_interruption, respectively. When system
+ * call interruption is disabled, the oxt::syscall wrapper functions will
+ * ignore interruption requests -- that is, they will never throw
+ * boost::thread_interrupted, nor will they return EINTR errors. This is similar
+ * to Boost thread interruption.
+ *
+ * <h2>How to interrupt</h2>
+ * Generally, oxt::thread::interrupt() and oxt::thread::interrupt_and_join()
+ * should be used for interrupting threads. These methods will interrupt
+ * the thread at all Boost interruption points, as well as system calls that
+ * are caled through the oxt::syscalls namespace. Do *not* use
+ * boost::thread::interrupt, because that will not honor system calls as
+ * interruption points.
+ *
+ * Under the hood, system calls are interrupted by sending a signal to the
+ * to a specific thread (note: sending a signal to a process will deliver the
+ * signal to the main thread).
+ *
+ * Any signal will do, but of course, one should only send a signal whose
+ * signal handler doesn't do undesirable things (such as aborting the entire
+ * program). That's why it's generally recommended that you only use
+ * oxt::INTERRUPTION_SIGNAL to interrupt system calls, because
+ * oxt::setup_syscall_interruption_support() installs an "nice" signal
+ * handler for that signal (though you should of course use
+ * oxt::thread::interrupt() instead of sending signals whenever
+ * possible).
+ *
+ * Note that sending a signal once may not interrupt the thread, because
+ * the thread may not be calling a system call at the time the signal was
+ * received. So one must keep sending signals periodically until the
+ * thread has quit.
+ *
+ * @warning
+ * After oxt::setup_syscall_interruption_support() is called, sending a signal
+ * will cause system calls to return with an EINTR error. The oxt::syscall
+ * functions will automatically take care of this, but if you're calling any
+ * system calls without using that namespace, then you should check for and
+ * take care of EINTR errors.
+ */
+
+// This is one of the things that Java is good at and C++ sucks at. Sigh...
+
+namespace oxt {
+	static const int INTERRUPTION_SIGNAL = SIGUSR2;
+	
+	/**
+	 * Setup system call interruption support.
+	 * This function may only be called once. It installs a signal handler
+	 * for INTERRUPTION_SIGNAL, so one should not install a different signal
+	 * handler for that signal after calling this function.
+	 *
+	 * @warning
+	 * After oxt::setup_syscall_interruption_support() is called, sending a signal
+	 * will cause system calls to return with an EINTR error. The oxt::syscall
+	 * functions will automatically take care of this, but if you're calling any
+	 * system calls without using that namespace, then you should check for and
+	 * take care of EINTR errors.
+	 */
+	void setup_syscall_interruption_support();
+	
+	/**
+	 * System call and C library call wrappers with interruption support.
+	 * These functions are interruption points, i.e. they throw
+	 * boost::thread_interrupted whenever the calling thread is interrupted
+	 * by oxt::thread::interrupt() or oxt::thread::interrupt_and_join().
+	 */
+	namespace syscalls {
+		ssize_t read(int fd, void *buf, size_t count);
+		ssize_t write(int fd, const void *buf, size_t count);
+		int close(int fd);
+		
+		int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+		int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+		int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
+		int listen(int sockfd, int backlog);
+		int socket(int domain, int type, int protocol);
+		int socketpair(int d, int type, int protocol, int sv[2]);
+		ssize_t recvmsg(int s, struct msghdr *msg, int flags);
+		ssize_t sendmsg(int s, const struct msghdr *msg, int flags);
+		int setsockopt(int s, int level, int optname, const void *optval,
+			socklen_t optlen);
+		int shutdown(int s, int how);
+		
+		FILE *fopen(const char *path, const char *mode);
+		int fclose(FILE *fp);
+		int unlink(const char *pathname);
+		int stat(const char *path, struct stat *buf);
+		
+		time_t time(time_t *t);
+		int usleep(useconds_t usec);
+		int nanosleep(const struct timespec *req, struct timespec *rem);
+		
+		pid_t fork();
+		int kill(pid_t pid, int sig);
+		pid_t waitpid(pid_t pid, int *status, int options);
+	}
+
+} // namespace oxt
+
+namespace boost {
+namespace this_thread {
+
+	/**
+	 * @intern
+	 */
+	extern thread_specific_ptr<bool> _syscalls_interruptable;
+	
+	/**
+	 * Check whether system calls should be interruptable in
+	 * the calling thread.
+	 */
+	bool syscalls_interruptable();
+	
+	class restore_syscall_interruption;
+
+	/**
+	 * Create this struct on the stack to temporarily enable system
+	 * call interruption, until the object goes out of scope.
+	 */
+	class enable_syscall_interruption {
+	private:
+		bool last_value;
+	public:
+		enable_syscall_interruption() {
+			if (_syscalls_interruptable.get() == NULL) {
+				last_value = true;
+				_syscalls_interruptable.reset(new bool(true));
+			} else {
+				last_value = *_syscalls_interruptable;
+				*_syscalls_interruptable = true;
+			}
+		}
+		
+		~enable_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+	
+	/**
+	 * Create this struct on the stack to temporarily disable system
+	 * call interruption, until the object goes out of scope.
+	 * While system call interruption is disabled, the functions in
+	 * InterruptableCalls will try until the return code is not EINTR.
+	 */
+	class disable_syscall_interruption {
+	private:
+		friend class restore_syscall_interruption;
+		bool last_value;
+	public:
+		disable_syscall_interruption() {
+			if (_syscalls_interruptable.get() == NULL) {
+				last_value = true;
+				_syscalls_interruptable.reset(new bool(false));
+			} else {
+				last_value = *_syscalls_interruptable;
+				*_syscalls_interruptable = false;
+			}
+		}
+		
+		~disable_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+	
+	/**
+	 * Creating an object of this class on the stack will restore the
+	 * system call interruption state to what it was before.
+	 */
+	class restore_syscall_interruption {
+	private:
+		int last_value;
+	public:
+		restore_syscall_interruption(const disable_syscall_interruption &intr) {
+			assert(_syscalls_interruptable.get() != NULL);
+			last_value = *_syscalls_interruptable;
+			*_syscalls_interruptable = intr.last_value;
+		}
+		
+		~restore_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+
+} // namespace this_thread
+} // namespace boost
+
+#endif /* _OXT_SYSTEM_CALLS_HPP_ */
+

data/ext/oxt/thread.cpp

@@ -0,0 +1,32 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 "thread.hpp"
+
+namespace oxt {
+	boost::mutex _next_thread_number_mutex;
+	unsigned int _next_thread_number = 0;
+}
+

data/ext/oxt/thread.hpp

@@ -0,0 +1,239 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008, 2009 Phusion
+ *
+ * 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 _OXT_THREAD_HPP_
+#define _OXT_THREAD_HPP_
+
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include "system_calls.hpp"
+#include "backtrace.hpp"
+#ifdef OXT_BACKTRACE_IS_ENABLED
+	#include <sstream>
+#endif
+#include <limits.h>  // for PTHREAD_STACK_MIN
+
+namespace oxt {
+
+extern boost::mutex _next_thread_number_mutex;
+extern unsigned int _next_thread_number;
+
+/**
+ * Enhanced thread class with support for:
+ * - user-defined stack size.
+ * - system call interruption.
+ * - backtraces.
+ */
+class thread: public boost::thread {
+private:
+	struct thread_data {
+		std::string name;
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			thread_registration *registration;
+			boost::mutex registration_lock;
+			bool done;
+		#endif
+	};
+	
+	typedef boost::shared_ptr<thread_data> thread_data_ptr;
+	
+	thread_data_ptr data;
+
+	void initialize_data(const std::string &thread_name) {
+		data = thread_data_ptr(new thread_data());
+		if (thread_name.empty()) {
+			boost::mutex::scoped_lock l(_next_thread_number_mutex);
+			std::stringstream str;
+			
+			str << "Thread #" << _next_thread_number;
+			_next_thread_number++;
+			data->name = str.str();
+		} else {
+			data->name = thread_name;
+		}
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			data->registration = NULL;
+			data->done = false;
+		#endif
+	}
+	
+	static void thread_main(boost::function<void ()> func, thread_data_ptr data) {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			initialize_backtrace_support_for_this_thread i(data->name);
+			data->registration = i.registration;
+		#endif
+		
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			// Put finalization code in a struct destructor,
+			// for exception safety.
+			struct finalization_routines {
+				thread_data_ptr &data;
+				
+				finalization_routines(thread_data_ptr &data_)
+					: data(data_) {}
+				
+				~finalization_routines() {
+					boost::mutex::scoped_lock l(data->registration_lock);
+					data->registration = NULL;
+					data->done = true;
+				}
+			};
+			finalization_routines f(data);
+		#endif
+		
+		func();
+	}
+	
+public:
+	/**
+	 * Create a new thread.
+	 *
+	 * @param func A function object which will be called as the thread's
+	 *     main function. This object must be copyable. <tt>func</tt> is
+	 *     copied into storage managed internally by the thread library,
+	 *     and that copy is invoked on a newly-created thread of execution.
+	 * @param name A name for this thread. If an empty string is given, then
+	 *     a name will be automatically chosen.
+	 * @param stack_size The stack size, in bytes, that the thread should
+	 *     have. If 0 is specified, the operating system's default stack
+	 *     size is used. If non-zero is specified, and the size is smaller
+	 *     than the operating system's minimum stack size, then the operating
+	 *     system's minimum stack size will be used.
+	 * @pre func must be copyable.
+	 * @throws boost::thread_resource_error Something went wrong during
+	 *     creation of the thread.
+	 */
+	explicit thread(boost::function<void ()> func, const std::string &name = "", unsigned int stack_size = 0) {
+		initialize_data(name);
+		
+		set_thread_main_function(boost::bind(thread_main, func, data));
+		
+		unsigned long min_stack_size;
+		#ifdef PTHREAD_STACK_MIN
+			// PTHREAD_STACK_MIN may not be a constant macro so we need
+			// to evaluate it dynamically.
+			min_stack_size = PTHREAD_STACK_MIN;
+		#else
+			// Assume minimum stack size is 128 KB.
+			min_stack_size = 128 * 1024;
+		#endif
+		if (stack_size < min_stack_size) {
+			stack_size = min_stack_size;
+		}
+		start_thread(stack_size);
+	}
+	
+	/**
+	 * Return this thread's name. The name was set during construction.
+	 */
+	std::string name() const throw() {
+		return data->name;
+	}
+	
+	/**
+	 * Return the current backtrace of the thread of execution, as a string.
+	 */
+	std::string backtrace() const throw() {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			boost::mutex::scoped_lock l(data->registration_lock);
+			if (data->registration == NULL) {
+				if (data->done) {
+					return "     (no backtrace: thread has quit)";
+				} else {
+					return "     (no backtrace: thread hasn't been started yet)";
+				}
+			} else {
+				spin_lock::scoped_lock l2(*data->registration->backtrace_lock);
+				return _format_backtrace(data->registration->backtrace);
+			}
+		#else
+			return "    (backtrace support disabled during compile time)";
+		#endif
+	}
+	
+	/**
+	 * Return the backtraces of all oxt::thread threads, as well as that of the
+	 * main thread, in a nicely formatted string.
+	 */
+	static std::string all_backtraces() throw() {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			boost::mutex::scoped_lock l(_thread_registration_mutex);
+			list<thread_registration *>::const_iterator it;
+			std::stringstream result;
+			
+			for (it = _registered_threads.begin(); it != _registered_threads.end(); it++) {
+				thread_registration *r = *it;
+				result << "Thread '" << r->name << "':" << endl;
+				
+				spin_lock::scoped_lock l(*r->backtrace_lock);
+				result << _format_backtrace(r->backtrace) << endl;
+			}
+			return result.str();
+		#else
+			return "(backtrace support disabled during compile time)";
+		#endif
+	}
+	
+	/**
+	 * Interrupt the thread. This method behaves just like
+	 * boost::thread::interrupt(), but will also respect the interruption
+	 * points defined in oxt::syscalls.
+	 *
+	 * Note that an interruption request may get lost, depending on the
+	 * current execution point of the thread. Thus, one should call this
+	 * method in a loop, until a certain goal condition has been fulfilled.
+	 * interrupt_and_join() is a convenience method that implements this
+	 * pattern.
+	 */
+	void interrupt() {
+		int ret;
+		
+		boost::thread::interrupt();
+		do {
+			ret = pthread_kill(native_handle(),
+				INTERRUPTION_SIGNAL);
+		} while (ret == EINTR);
+	}
+	
+	/**
+	 * Keep interrupting the thread until it's done, then join it.
+	 *
+	 * @throws boost::thread_interrupted The calling thread has been
+	 *    interrupted before we could join this thread.
+	 */
+	void interrupt_and_join() {
+		bool done = false;
+		while (!done) {
+			interrupt();
+			done = timed_join(boost::posix_time::millisec(10));
+		}
+	}
+};
+
+} // namespace oxt
+
+#endif /* _OXT_THREAD_HPP_ */
+

data/ext/oxt/tracable_exception.cpp

@@ -0,0 +1,87 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 "tracable_exception.hpp"
+#include "backtrace.hpp"
+
+#ifdef OXT_BACKTRACE_IS_ENABLED
+
+#include <boost/thread/mutex.hpp>
+#include "macros.hpp"
+
+namespace oxt {
+
+using namespace std;
+
+tracable_exception::tracable_exception() {
+	spin_lock *lock = _get_backtrace_lock();
+	if (OXT_LIKELY(lock != NULL)) {
+		spin_lock::scoped_lock l(*lock);
+		vector<trace_point *> *bt = _get_current_backtrace();
+		vector<trace_point *>::const_iterator it;
+		
+		for (it = bt->begin(); it != bt->end(); it++) {
+			trace_point *p = new trace_point(
+				(*it)->function,
+				(*it)->source,
+				(*it)->line,
+				true);
+			backtrace_copy.push_back(p);
+		}
+	}
+}
+
+tracable_exception::tracable_exception(const tracable_exception &other) {
+	list<trace_point *>::const_iterator it;
+	for (it = other.backtrace_copy.begin(); it != other.backtrace_copy.end(); it++) {
+		trace_point *p = new trace_point(
+			(*it)->function,
+			(*it)->source,
+			(*it)->line,
+			true);
+		backtrace_copy.push_back(p);
+	}
+}
+
+tracable_exception::~tracable_exception() throw() {
+	list<trace_point *>::iterator it;
+	for (it = backtrace_copy.begin(); it != backtrace_copy.end(); it++) {
+		delete *it;
+	}
+}
+
+string
+tracable_exception::backtrace() const throw() {
+	return _format_backtrace(&backtrace_copy);
+}
+
+const char *
+tracable_exception::what() const throw() {
+	return "oxt::tracable_exception";
+}
+
+} // namespace oxt
+
+#endif
+

data/ext/oxt/tracable_exception.hpp

@@ -0,0 +1,35 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 _OXT_TRACABLE_EXCEPTION_HPP_
+#define _OXT_TRACABLE_EXCEPTION_HPP_
+
+#if defined(NDEBUG) || defined(OXT_DISABLE_BACKTRACES)
+	#include "detail/tracable_exception_disabled.hpp"
+#else
+	#include "detail/tracable_exception_enabled.hpp"
+#endif
+
+#endif /* _OXT_TRACABLE_EXCEPTION_HPP_ */
+

data/ext/phusion_passenger/extconf.rb

@@ -0,0 +1,36 @@
+#  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.
+require 'mkmf'
+$LIBS=""
+
+if RUBY_PLATFORM =~ /solaris/
+	have_library('xnet')
+	$CFLAGS << " -D_XPG4_2"
+	if RUBY_PLATFORM =~ /solaris2.9/
+		$CFLAGS << " -D__SOLARIS9__"
+	end
+end
+
+with_cflags($CFLAGS) do
+	create_makefile('native_support')
+end