passenger 4.0.20 → 4.0.21

data/ext/apache2/MergeDirConfig.cpp

@@ -108,3 +108,4 @@
 			base->loadShellEnvvars :
 			add->loadShellEnvvars;
 	
+

data/ext/apache2/MergeDirConfig.cpp.erb

@@ -78,4 +78,4 @@ end
 	<% else
 		raise "Unknown option type #{option[:type].inspect} for option #{option[:name]}"
 	end %>
-<% end %>
+<% end %>

data/ext/apache2/SetHeaders.cpp

@@ -0,0 +1,73 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2013 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.
+ */
+
+/*
+ * SetHeaders.cpp is automatically generated from SetHeaders.cpp.erb,
+ * using definitions from lib/phusion_passenger/apache2/config_options.rb.
+ * Edits to SetHeaders.cpp will be lost.
+ *
+ * To update SetHeaders.cpp:
+ *   rake apache2
+ *
+ * To force regeneration of SetHeaders.cpp:
+ *   rm -f ext/apache2/SetHeaders.cpp
+ *   rake ext/apache2/SetHeaders.cpp
+ */
+
+
+
+
+	
+		addHeader(output, "PASSENGER_RUBY", config->ruby ? config->ruby : serverConfig.defaultRuby);
+	
+
+	
+		addHeader(r, output, "PASSENGER_MIN_INSTANCES", config->minInstances);
+	
+
+	
+		addHeader(output, "PASSENGER_USER", config->user);
+	
+
+	
+		addHeader(output, "PASSENGER_GROUP", config->group);
+	
+
+	
+		addHeader(r, output, "PASSENGER_MAX_REQUESTS", config->maxRequests);
+	
+
+	
+		addHeader(r, output, "PASSENGER_START_TIMEOUT", config->startTimeout);
+	
+
+	
+		addHeader(r, output, "PASSENGER_MAX_REQUEST_QUEUE_SIZE", config->maxRequestQueueSize);
+	
+
+	
+		addHeader(r, output, "PASSENGER_LOAD_SHELL_ENVVARS", config->loadShellEnvvars);
+	
+

data/ext/apache2/SetHeaders.cpp.erb

@@ -0,0 +1,88 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2013 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.
+ */
+
+/*
+ * SetHeaders.cpp is automatically generated from SetHeaders.cpp.erb,
+ * using definitions from lib/phusion_passenger/apache2/config_options.rb.
+ * Edits to SetHeaders.cpp will be lost.
+ *
+ * To update SetHeaders.cpp:
+ *   rake apache2
+ *
+ * To force regeneration of SetHeaders.cpp:
+ *   rm -f ext/apache2/SetHeaders.cpp
+ *   rake ext/apache2/SetHeaders.cpp
+ */
+
+<%
+require 'phusion_passenger/apache2/config_options'
+
+def filter_eligible_options(options)
+	return options.reject do |option|
+		option[:alias_for] ||
+			option.fetch(:field, true).nil? ||
+			option[:field].to_s =~ /\./ ||
+			(option.has_key?(:header) && !option[:header])
+	end
+end
+
+def struct_field_for(option)
+	if option.has_key?(:field)
+		return option[:field]
+	else
+		result = option[:name].sub(/^Passenger/, '')
+		result[0] = result[0..0].downcase
+		return result
+	end
+end
+
+def header_name_for(option)
+	if option[:header]
+		return option[:header].inspect
+	else
+		result = option[:name].sub(/^Passenger/, '')
+		result.gsub!(/([A-Z])/, '_\1')
+		return "PASSENGER#{result.upcase}".inspect
+	end
+end
+
+def header_expression_for(option)
+	if option[:header_expression]
+		return option[:header_expression]
+	else
+		return "config->" + struct_field_for(option)
+	end
+end
+%>
+
+<% for option in filter_eligible_options(APACHE2_DIRECTORY_CONFIGURATION_OPTIONS) %>
+	<% if option[:type] == :string %>
+		addHeader(output, <%= header_name_for(option) %>, <%= header_expression_for(option) %>);
+	<% elsif option[:type] == :integer || option[:type] == :flag %>
+		addHeader(r, output, <%= header_name_for(option) %>, <%= header_expression_for(option) %>);
+	<% else %>
+		<% raise "Unknown option type #{option[:type].inspect} for option #{option[:name]}" %>
+	<% end %>
+<% end %>

data/ext/boost/algorithm/string/detail/find_format.hpp

@@ -56,7 +56,7 @@ namespace boost {
                 // Copy the beginning of the sequence
                 Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
                 // Format find result
-                // Copy formated result
+                // Copy formatted result
                 Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
                 // Copy the rest of the sequence
                 Output = std::copy( M.end(), ::boost::end(Input), Output );
@@ -118,11 +118,11 @@ namespace boost {
 
                 InputT Output;
                 // Copy the beginning of the sequence
-                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
-                // Copy formated result
-                insert( Output, ::boost::end(Output), M.format_result() );
+                boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
+                // Copy formatted result
+                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
                 // Copy the rest of the sequence
-                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
+                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
 
                 return Output;
             }

data/ext/boost/algorithm/string/detail/find_format_all.hpp

@@ -58,7 +58,7 @@ namespace boost {
                 {
                     // Copy the beginning of the sequence
                     Output = std::copy( LastMatch, M.begin(), Output );
-                    // Copy formated result
+                    // Copy formatted result
                     Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
 
                     // Proceed to the next match
@@ -134,9 +134,9 @@ namespace boost {
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    insert( Output, ::boost::end(Output), LastMatch, M.begin() );
-                    // Copy formated result
-                    insert( Output, ::boost::end(Output), M.format_result() );
+                    boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );
+                    // Copy formatted result
+                    boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
 
                     // Proceed to the next match
                     LastMatch=M.end();
@@ -218,7 +218,7 @@ namespace boost {
                     // Adjust search iterator
                     SearchIt=M.end();
 
-                    // Copy formated replace to the storage
+                    // Copy formatted replace to the storage
                     ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
 
                     // Find range for a next match

data/ext/boost/algorithm/string/detail/finder.hpp

@@ -92,7 +92,7 @@ namespace boost {
 
 //  find last functor -----------------------------------------------//
 
-            // find the last match a subseqeunce in the sequence ( functor )
+            // find the last match a subsequence in the sequence ( functor )
             /*
                 Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, returns <End,End>

data/ext/boost/algorithm/string/formatter.hpp

@@ -39,7 +39,7 @@ namespace boost {
             Constructs a \c const_formatter. Const formatter always returns
             the same value, regardless of the parameter.
 
-            \param Format A predefined value used as a result for formating
+            \param Format A predefined value used as a result for formatting
             \return An instance of the \c const_formatter object.
         */
         template<typename RangeT>
@@ -95,7 +95,7 @@ namespace boost {
             to extract a portion of the formatted sequence. The first finder's match is returned 
             as a result
 
-            \param Finder a finder used to select a portion of the formated sequence
+            \param Finder a finder used to select a portion of the formatted sequence
             \return An instance of the \c dissect_formatter object.
         */
         template<typename FinderT>

data/ext/boost/assert.hpp

@@ -101,7 +101,12 @@ namespace boost
               << "***** Internal Program Error - assertion (" << expr << ") failed in "
               << function << ":\n"
               << file << '(' << line << "): " << msg << std::endl;
-            std::abort();
+			#ifdef UNDER_CE
+				// The Windows CE CRT library does not have abort() so use exit(-1) instead.
+				std::exit(-1);
+			#else
+				std::abort();
+			#endif
           }
         } // detail
       } // assertion

data/ext/boost/atomic.hpp

@@ -0,0 +1,18 @@
+#ifndef BOOST_ATOMIC_HPP
+#define BOOST_ATOMIC_HPP
+
+//  Copyright (c) 2011 Helge Bahmann
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// This header includes all Boost.Atomic public headers
+
+#include <boost/atomic/atomic.hpp>
+
+#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#endif

data/ext/boost/atomic/atomic.hpp

@@ -0,0 +1,241 @@
+#ifndef BOOST_ATOMIC_ATOMIC_HPP
+#define BOOST_ATOMIC_ATOMIC_HPP
+
+//  Copyright (c) 2011 Helge Bahmann
+//  Copyright (c) 2013 Tim Blechmann
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstddef>
+#include <boost/cstdint.hpp>
+
+#include <boost/memory_order.hpp>
+
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/platform.hpp>
+#include <boost/atomic/detail/type-classification.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1400
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/mpl/and.hpp>
+#endif
+
+#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+#ifndef BOOST_ATOMIC_CHAR_LOCK_FREE
+#define BOOST_ATOMIC_CHAR_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_CHAR16_T_LOCK_FREE
+#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_CHAR32_T_LOCK_FREE
+#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_WCHAR_T_LOCK_FREE
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_SHORT_LOCK_FREE
+#define BOOST_ATOMIC_SHORT_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_INT_LOCK_FREE
+#define BOOST_ATOMIC_INT_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_LONG_LOCK_FREE
+#define BOOST_ATOMIC_LONG_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_LLONG_LOCK_FREE
+#define BOOST_ATOMIC_LLONG_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_POINTER_LOCK_FREE
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 0
+#endif
+
+#define BOOST_ATOMIC_ADDRESS_LOCK_FREE BOOST_ATOMIC_POINTER_LOCK_FREE
+
+#ifndef BOOST_ATOMIC_BOOL_LOCK_FREE
+#define BOOST_ATOMIC_BOOL_LOCK_FREE 0
+#endif
+
+#ifndef BOOST_ATOMIC_THREAD_FENCE
+#define BOOST_ATOMIC_THREAD_FENCE 0
+inline void atomic_thread_fence(memory_order)
+{
+}
+#endif
+
+#ifndef BOOST_ATOMIC_SIGNAL_FENCE
+#define BOOST_ATOMIC_SIGNAL_FENCE 0
+inline void atomic_signal_fence(memory_order order)
+{
+    atomic_thread_fence(order);
+}
+#endif
+
+template<typename T>
+class atomic :
+    public atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-integral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    >
+{
+private:
+    typedef T value_type;
+    typedef atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-itegral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    > super;
+public:
+    atomic(void) BOOST_NOEXCEPT : super() {}
+    BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT : super(v) {}
+
+    value_type operator=(value_type v) volatile BOOST_NOEXCEPT
+    {
+        this->store(v);
+        return v;
+    }
+
+    operator value_type(void) volatile const BOOST_NOEXCEPT
+    {
+        return this->load();
+    }
+
+#ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
+private:
+    atomic(const atomic &) /* =delete */ ;
+    atomic & operator=(const atomic &) volatile /* =delete */ ;
+#else
+    atomic(const atomic &) = delete;
+    atomic & operator=(const atomic &) volatile = delete;
+#endif
+};
+
+typedef atomic<char> atomic_char;
+typedef atomic<unsigned char> atomic_uchar;
+typedef atomic<signed char> atomic_schar;
+typedef atomic<uint8_t> atomic_uint8_t;
+typedef atomic<int8_t> atomic_int8_t;
+typedef atomic<unsigned short> atomic_ushort;
+typedef atomic<short> atomic_short;
+typedef atomic<uint16_t> atomic_uint16_t;
+typedef atomic<int16_t> atomic_int16_t;
+typedef atomic<unsigned int> atomic_uint;
+typedef atomic<int> atomic_int;
+typedef atomic<uint32_t> atomic_uint32_t;
+typedef atomic<int32_t> atomic_int32_t;
+typedef atomic<unsigned long> atomic_ulong;
+typedef atomic<long> atomic_long;
+typedef atomic<uint64_t> atomic_uint64_t;
+typedef atomic<int64_t> atomic_int64_t;
+#ifdef BOOST_HAS_LONG_LONG
+typedef atomic<boost::ulong_long_type> atomic_ullong;
+typedef atomic<boost::long_long_type> atomic_llong;
+#endif
+typedef atomic<void*> atomic_address;
+typedef atomic<bool> atomic_bool;
+typedef atomic<wchar_t> atomic_wchar_t;
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+typedef atomic<char16_t> atomic_char16_t;
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+typedef atomic<char32_t> atomic_char32_t;
+#endif
+
+typedef atomic<int_least8_t> atomic_int_least8_t;
+typedef atomic<uint_least8_t> atomic_uint_least8_t;
+typedef atomic<int_least16_t> atomic_int_least16_t;
+typedef atomic<uint_least16_t> atomic_uint_least16_t;
+typedef atomic<int_least32_t> atomic_int_least32_t;
+typedef atomic<uint_least32_t> atomic_uint_least32_t;
+typedef atomic<int_least64_t> atomic_int_least64_t;
+typedef atomic<uint_least64_t> atomic_uint_least64_t;
+typedef atomic<int_fast8_t> atomic_int_fast8_t;
+typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
+typedef atomic<int_fast16_t> atomic_int_fast16_t;
+typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
+typedef atomic<int_fast32_t> atomic_int_fast32_t;
+typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
+typedef atomic<int_fast64_t> atomic_int_fast64_t;
+typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
+typedef atomic<intmax_t> atomic_intmax_t;
+typedef atomic<uintmax_t> atomic_uintmax_t;
+
+typedef atomic<std::size_t> atomic_size_t;
+typedef atomic<std::ptrdiff_t> atomic_ptrdiff_t;
+
+// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config.
+#if !defined(__PGIC__)
+
+#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \
+    || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
+    || defined(__CYGWIN__) \
+    || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
+    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+typedef atomic<intptr_t> atomic_intptr_t;
+typedef atomic<uintptr_t> atomic_uintptr_t;
+#elif defined(__GNUC__) || defined(__clang__)
+#if defined(__INTPTR_TYPE__)
+typedef atomic< __INTPTR_TYPE__ > atomic_intptr_t;
+#endif
+#if defined(__UINTPTR_TYPE__)
+typedef atomic< __UINTPTR_TYPE__ > atomic_uintptr_t;
+#endif
+#endif
+
+#endif
+
+#ifndef BOOST_ATOMIC_FLAG_LOCK_FREE
+#define BOOST_ATOMIC_FLAG_LOCK_FREE 0
+class atomic_flag
+{
+public:
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(false) {}
+
+    bool
+    test_and_set(memory_order order = memory_order_seq_cst) BOOST_NOEXCEPT
+    {
+        return v_.exchange(true, order);
+    }
+
+    void
+    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        v_.store(false, order);
+    }
+private:
+    atomic_flag(const atomic_flag &) /* = delete */ ;
+    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
+    atomic<bool> v_;
+};
+#endif
+
+}
+
+#endif