passenger 4.0.27 → 4.0.28

data/doc/Users guide Standalone.txt

@@ -102,6 +102,7 @@ Here is an example configuration file:
 ------------------
 
 
+[[advanced_configuration]]
 === Advanced configuration
 
 Phusion Passenger Standalone is built on the same technology that powers link:Users%20guide%20Nginx.html[Phusion Passenger for Nginx], so any configuration option supported by Phusion Passenger for Nginx can be applied to Standalone as well. You can do this by editing the Standalone configuration template directly.

data/doc/users_guide_snippets/environment_variables.txt

@@ -226,7 +226,7 @@ PATH=/usr/bin:/usr/local/bin
 You can pass environment variables to Phusion Passenger-served apps through various methods:
 
  * When running Apache, use the `PassEnv` and `SetEnv` directives of link:http://httpd.apache.org/docs/2.4/mod/mod_env.html[mod_env]. This is supported starting from Phusion Passenger 4.0.
- * When running Nginx, use the `env` directive. Unlike Apache, Nginx's `env` directive can only be set globally and cannot be customized on a per-virtual host basis.
+ * When running Nginx, use the <<passenger_set_cgi_param,passenger_set_cgi_param>> directive.
  * Through your `bashrc`. Starting from version 4.0, Phusion Passenger 4.0 spawns applications through bash and inherit all bash environment variables. Phusion Passenger Standalone tends to be started from the shell and thus inherits all environment variables set by the shell.
  * Through Apache and Nginx, as described earlier in this chapter. Any environment variables that you set on Apache and Nginx itself are inherited by Phusion Passenger, and thus by Phusion Passenger-served apps as well.
  * Through the application itself. Most programming languages provide APIs for setting environment variables. For example in Ruby you can write:

data/doc/users_guide_snippets/installation.txt

@@ -191,6 +191,8 @@ endif::[]
 
 === Installing or upgrading on Red Hat, Fedora, CentOS or ScientificLinux
 
+WARNING: The RPMs are currently unmaintained. As such, the repository only contains Phusion Passenger 3.x (the latest version is 4.x), which did not support Node.js, Meteor, multiple Rubies, etc. For more recent versions of Phusion Passenger, you are suggested to install from gem or tarball instead.
+
 YUM repositories with RPMs are maintained by link:https://github.com/erikogan/passenger[Erik Ogan] and link:http://stealthymonkeys.com/[Stealthy Monkeys Consulting]. Only packages for the open source version of Phusion Passenger are provided. link:https://www.phusionpassenger.com/enterprise[Phusion Passenger Enterprise] customers should use the <<rubygems_generic_install,generic RubyGems installation method>> or <<tarball_generic_install,the generic tarball installation method>> instead.
 
 If you use YUM to install Phusion Passenger then you do not need to run `passenger-install-apache2-module` or `passenger-install-nginx-module`. The YUM packages contain all the binaries that you need. You also don't need to modify any Apache or Nginx configuration to get them to load Phusion Passenger, the packages provide configuration snippets for you as well.

data/doc/users_guide_snippets/tips.txt

@@ -386,6 +386,124 @@ References:
 
 - link:http://blog.phusion.nl/2013/01/22/phusion-passenger-4-technology-preview-out-of-band-work/[The Phusion Blog article which first introduced this feature.]
 
+=== Hooks
+
+:version: 4.0.28
+include::since_version.txt[]
+
+Phusion Passenger provides a powerful but simple hooking system, which allows you to extend many aspects of Phusion Passenger's behavior. The hooking system works by executing commands during certain events. Event parameters are passed to the command in the form of environment variables.
+
+ifdef::apache[]
+You can define hooks by setting the configuration option `PassengerCtl hook_<HOOK NAME> <COMMAND TO EXECUTE>`.
+endif::apache[]
+ifdef::nginx[]
+You can define hooks by setting the configuration option `passenger_ctl hook_<HOOK NAME> <COMMAND TO EXECUTE>;`.
+endif::nginx[]
+ifdef::standalone[]
+You can define hooks by <<advanced_configuration,editing the advanced configuration file>>, and adding the configuration option `passenger_ctl hook_<HOOK NAME> <COMMAND TO EXECUTE>;`.
+endif::standalone[]
+
+==== Example
+
+The hook system is best demonstrated with a simple example. In the following example we will hook into the `attached_process` event. This event is called whenever Phusion Passenger has successfully spawned an application processes and added it to the process pool. We print the process's PID and application root.
+
+First, let's create a script `/home/phusion/attached.sh` which is to be called during the hook.
+
+[source,sh]
+---------------------------------------------------
+#!/bin/sh
+echo "Attached process $PASSENGER_PROCESS_PID for app $PASSENGER_APP_ROOT."
+---------------------------------------------------
+
+Then we make it executable:
+
+---------------------------------------------------
+chmod +x /home/phusion/attached.sh
+---------------------------------------------------
+
+And we define the hook in the configuration file:
+
+ifdef::apache[]
+---------------------------------------------------
+PassengerCtl hook_attached_process /home/phusion/attached.sh
+---------------------------------------------------
+endif::apache[]
+ifdef::nginx[]
+---------------------------------------------------
+passenger_ctl hook_attached_process /home/phusion/attached.sh;
+---------------------------------------------------
+endif::nginx[]
+ifdef::standalone[]
+---------------------------------------------------
+passenger_ctl hook_attached_process /home/phusion/attached.sh;
+---------------------------------------------------
+endif::standalone[]
+
+Now restart the web server and access a web app hosted by Phusion Passenger. You should see our message in the web server error log:
+
+---------------------------------------------------
+[ 2013-12-10 16:12:21.6456 28934/0x1064cb000 Hooks.h:129 ]: Running attached_process hook script: /home/phusion/attached.sh
+Attached process 28303 for app /webapps/foobar.
+[ 2013-12-10 16:12:21.6580 28934/0x1064cb000 Hooks.h:161 ]: Hook script /home/phusion/attached.sh (PID 28948) exited with status 0
+---------------------------------------------------
+
+==== Environment
+
+A lot of information is passed to hook scripts in the form of environment variables. They are all uppercase and begin with `PASSENGER_`. Some environment variables are passed to all hook scripts, others are passed depending on the hook.
+
+Here are some of the environment variables which are passed to all hooks, unless documented otherwise:
+
+ * `PASSENGER_VERSION`
+ * `PASSENGER_PASSENGER_ROOT`
+ * `PASSENGER_SERVER_INSTANCE_DIR`
+ * `PASSENGER_GENERATION_PATH`
+
+==== Blocking and concurrency
+
+All hooks block. That is, Phusion Passenger waits until your hook command is finished. You should therefore be careful when writing hook scripts: if your script never finishes, so Phusion Passenger does not do that either.
+
+If you have a bug in your script and it blocks, then you will be able to see that using the command `passenger-status --show=backtraces` which prints the backtraces of all threads in the Phusion Passenger HelperAgent. Look for the `runSingleHookScript` function in the backtrace. The following example shows at line 2 that Phusion Passenger is waiting for the hook script `/home/phusion/badscript.sh`.
+
+---------------------------------------------------------------------------------------------------
+Thread 'Group process spawner: /home/phusion/webapp.test#default' (0x1062d4000):
+     in 'bool Passenger::runSingleHookScript(Passenger::HookScriptOptions &, const string &, const vector<pair<string, string> > &)' (Hooks.h:116) -- /home/phusion/badscript.sh
+     in 'bool Passenger::runHookScripts(Passenger::HookScriptOptions &)' (Hooks.h:159)
+     in 'void Passenger::ApplicationPool2::Group::spawnThreadRealMain(const SpawnerPtr &, const Passenger::ApplicationPool2::Options &, unsigned int)' (Implementation.cpp:878)
+---------------------------------------------------------------------------------------------------
+
+Hooks may be called concurrently. For example, while the `attached_process` hook is being called, a `detached_process` hook may be called, perhaps even for the same application. It is your responsibility to ensure that your hook scripts are concurrency-safe, e.g. by employing locks and other concurrency control techniques.
+
+==== Error handling
+
+If a hook script fails -- that is, if it exits with anything other than exit code 0 -- then the error handling depends on the hook. Some hooks will abort, other hooks will ignore the error. In all cases, the result of the hook script is printed to the log.
+
+==== Available hooks
+
+`before_watchdog_initialization`::
+	Called at the very beginning of Phusion Passenger's life cycle, during the start of the Watchdog process. The first hook is called before initialization is performed (before the HelperAgent is started). Errors in the hook script cause Phusion Passenger to abort.
+`after_watchdog_initialization`::
+	Like `before_watchdog_initialization`, but called after initialization of all Phusion Passenger agent processes. Errors in the hook script cause Phusion Passenger to abort.
+`attached_process`::
+	Called when Phusion Passenger has successfully spawned an application processes and added it to the process pool. Extra environment variables: `PASSENGER_PROCESS_PID`, `PASSENGER_APP_ROOT`. Errors in the hook script are ignored.
+`detached_process`::
+	Called when Phusion Passenger has removed an application process from the process pool. This could happen when:
++
+ - The process has crashed, and Phusion Passenger noticed it.
+ - Phusion Passenger has shut down a process because it's been idle for too long.
+ - The administrator configured different resource limits, and Phusion Passenger is starting or shutting down processes in response.
+ - Phusion Passenger itself is shutting down.
++
+Extra environment variables: `PASSENGER_PROCESS_PID`, `PASSENGER_APP_ROOT`. Errors in the hook script are ignored.
+
+`after_initialize_supergroup`::
+	Called right after Phusion Passenger has allocated data structures for an application, and is about to spawn a process for the first time for this application. Errors in the hook script are ignored. Extra environment variables: `PASSENGER_APP_ROOT`.
+`before_destroy_supergroup`::
+	Called right before Phusion Passenger decallocates data structures for an application. Errors in the hook script are ignored.
++
+Note that the `after_initialize_supergroup` hook may be called while this hook is still being executed, so make sure that operations don't conflict with each other.
++
+Extra environment variables: `PASSENGER_APP_ROOT`.
+
 [[flying_passenger]]
 === Flying Passenger
 :version: 4.0.6

data/ext/apache2/Configuration.cpp

@@ -251,7 +251,6 @@ DEFINE_SERVER_STR_CONFIG_SETTER(cmd_passenger_default_ruby, defaultRuby)
 DEFINE_SERVER_INT_CONFIG_SETTER(cmd_passenger_log_level, logLevel, unsigned int, 0)
 DEFINE_SERVER_STR_CONFIG_SETTER(cmd_passenger_debug_log_file, debugLogFile)
 DEFINE_SERVER_INT_CONFIG_SETTER(cmd_passenger_max_pool_size, maxPoolSize, unsigned int, 1)
-DEFINE_SERVER_INT_CONFIG_SETTER(cmd_passenger_max_instances_per_app, maxInstancesPerApp, unsigned int, 0)
 DEFINE_SERVER_INT_CONFIG_SETTER(cmd_passenger_pool_idle_time, poolIdleTime, unsigned int, 0)
 DEFINE_SERVER_BOOLEAN_CONFIG_SETTER(cmd_passenger_user_switching, userSwitching)
 DEFINE_SERVER_STR_CONFIG_SETTER(cmd_passenger_default_user, defaultUser)
@@ -444,11 +443,6 @@ const command_rec passenger_commands[] = {
 		NULL,
 		RSRC_CONF,
 		"The maximum number of simultaneously alive application instances."),
-	AP_INIT_TAKE1("PassengerMaxInstancesPerApp",
-		(Take1Func) cmd_passenger_max_instances_per_app,
-		NULL,
-		RSRC_CONF,
-		"The maximum number of simultaneously alive application instances a single application may occupy."),
 	AP_INIT_TAKE1("PassengerPoolIdleTime",
 		(Take1Func) cmd_passenger_pool_idle_time,
 		NULL,

data/ext/apache2/Configuration.hpp

@@ -260,10 +260,6 @@ struct ServerConfig {
 	 * instances. */
 	unsigned int maxPoolSize;
 	
-	/** The maximum number of simultaneously alive Rails application
-	 * that a single Rails application may occupy. */
-	unsigned int maxInstancesPerApp;
-	
 	/** The maximum number of seconds that an application may be
 	 * idle before it gets terminated. */
 	unsigned int poolIdleTime;
@@ -296,7 +292,6 @@ struct ServerConfig {
 		logLevel           = DEFAULT_LOG_LEVEL;
 		debugLogFile       = NULL;
 		maxPoolSize        = DEFAULT_MAX_POOL_SIZE;
-		maxInstancesPerApp = DEFAULT_MAX_INSTANCES_PER_APP;
 		poolIdleTime       = DEFAULT_POOL_IDLE_TIME;
 		userSwitching      = true;
 		defaultUser        = DEFAULT_WEB_APP_USER;

data/ext/apache2/ConfigurationCommands.cpp

@@ -89,6 +89,13 @@
 		"The minimum number of application instances to keep when cleaning idle instances."),
 
 	
+	AP_INIT_TAKE1("PassengerMaxInstancesPerApp",
+		(Take1Func) cmd_passenger_max_instances_per_app,
+		NULL,
+		RSRC_CONF,
+		"The maximum number of simultaneously alive application instances a single application may occupy."),
+
+	
 	AP_INIT_TAKE1("PassengerUser",
 		(Take1Func) cmd_passenger_user,
 		NULL,

data/ext/apache2/ConfigurationFields.hpp

@@ -48,6 +48,8 @@
 	Threeway highPerformance;
 	/** Whether to load environment variables from the shell before running the application. */
 	Threeway loadShellEnvvars;
+	/** The maximum number of simultaneously alive application instances a single application may occupy. */
+	int maxInstancesPerApp;
 	/** The maximum number of queued requests. */
 	int maxRequestQueueSize;
 	/** The maximum number of requests that an application instance may process. */

data/ext/apache2/ConfigurationSetters.cpp

@@ -105,6 +105,30 @@
 		}
 	
 	
+		static const char *
+		cmd_passenger_max_instances_per_app(cmd_parms *cmd, void *pcfg, const char *arg) {
+			DirConfig *config = (DirConfig *) pcfg;
+			char *end;
+			long result;
+
+			result = strtol(arg, &end, 10);
+			if (*end != '\0') {
+				string message = "Invalid number specified for ";
+				message.append(cmd->directive->directive);
+				message.append(".");
+
+				char *messageStr = (char *) apr_palloc(cmd->temp_pool,
+					message.size() + 1);
+				memcpy(messageStr, message.c_str(), message.size() + 1);
+				return messageStr;
+			
+			} else {
+				config->maxInstancesPerApp = (int) result;
+				return NULL;
+			}
+		}
+	
+	
 		static const char *
 		cmd_passenger_user(cmd_parms *cmd, void *pcfg, const char *arg) {
 			DirConfig *config = (DirConfig *) pcfg;

data/ext/apache2/CreateDirConfig.cpp

@@ -43,6 +43,7 @@
 				config->nodejs = NULL;
 				config->appEnv = NULL;
 				config->minInstances = UNSET_INT_VALUE;
+				config->maxInstancesPerApp = UNSET_INT_VALUE;
 				config->user = NULL;
 				config->group = NULL;
 				config->errorOverride = DirConfig::UNSET;

data/ext/apache2/Hooks.cpp

@@ -1281,7 +1281,6 @@ public:
 			.set    ("default_ruby", serverConfig.defaultRuby)
 			.setInt ("max_pool_size", serverConfig.maxPoolSize)
 			.setInt ("pool_idle_time", serverConfig.poolIdleTime)
-			.setInt ("max_instances_per_app", serverConfig.maxInstancesPerApp)
 			.set    ("analytics_log_user", serverConfig.analyticsLogUser)
 			.set    ("analytics_log_group", serverConfig.analyticsLogGroup)
 			.set    ("union_station_gateway_address", serverConfig.unionStationGatewayAddress)

data/ext/apache2/MergeDirConfig.cpp

@@ -75,6 +75,13 @@
 	
 
 	
+		config->maxInstancesPerApp =
+			(add->maxInstancesPerApp == UNSET_INT_VALUE) ?
+			base->maxInstancesPerApp :
+			add->maxInstancesPerApp;
+	
+
+	
 		config->user =
 			(add->user == NULL) ?
 			base->user :

data/ext/apache2/SetHeaders.cpp

@@ -56,7 +56,11 @@
 	
 
 	
-		addHeader(r, output, "PASSENGER_MIN_INSTANCES", config->minInstances);
+		addHeader(r, output, "PASSENGER_MIN_PROCESSES", config->minInstances);
+	
+
+	
+		addHeader(r, output, "PASSENGER_MAX_PROCESSES", config->maxInstancesPerApp);
 	
 
 	

data/ext/boost/cregex.hpp

@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to 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)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org/libs/regex for most recent version.
+  *   FILE         cregex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares POSIX API functions
+  *                + boost::RegEx high level wrapper.
+  */
+
+#ifndef BOOST_RE_CREGEX_HPP
+#define BOOST_RE_CREGEX_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#include <boost/regex/v4/cregex.hpp>
+
+#endif /* include guard */
+
+
+
+
+
+
+
+
+
+

data/ext/boost/libs/regex/src/c_regex_traits.cpp

@@ -0,0 +1,193 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to 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)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE:        c_regex_traits.cpp
+  *   VERSION:     see <boost/version.hpp>
+  *   DESCRIPTION: Implements out of line c_regex_traits<char> members
+  */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include "internals.hpp"
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
+
+#include <boost/regex/v4/c_regex_traits.hpp>
+#include <boost/regex/v4/primary_transform.hpp>
+#include <boost/regex/v4/regex_traits_defaults.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+   using ::strxfrm; using ::isspace;
+   using ::ispunct; using ::isalpha;
+   using ::isalnum; using ::iscntrl;
+   using ::isprint; using ::isupper;
+   using ::islower; using ::isdigit;
+   using ::isxdigit; using ::strtol;
+}
+#endif
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost{
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform(const char* p1, const char* p2)
+{ 
+   std::string result(10, ' ');
+   std::size_t s = result.size();
+   std::size_t r;
+   std::string src(p1, p2);
+   while(s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))
+   {
+      result.append(r - s + 3, ' ');
+      s = result.size();
+   }
+   result.erase(r);
+   return result; 
+}
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform_primary(const char* p1, const char* p2)
+{
+   static char s_delim;
+   static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
+   std::string result;
+   //
+   // What we do here depends upon the format of the sort key returned by
+   // sort key returned by this->transform:
+   //
+   switch(s_collate_type)
+   {
+   case ::boost::re_detail::sort_C:
+   case ::boost::re_detail::sort_unknown:
+      // the best we can do is translate to lower case, then get a regular sort key:
+      {
+         result.assign(p1, p2);
+         for(std::string::size_type i = 0; i < result.size(); ++i)
+            result[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(result[i])));
+         result = transform(&*result.begin(), &*result.begin() + result.size());
+         break;
+      }
+   case ::boost::re_detail::sort_fixed:
+      {
+         // get a regular sort key, and then truncate it:
+         result = transform(p1, p2);
+         result.erase(s_delim);
+         break;
+      }
+   case ::boost::re_detail::sort_delim:
+         // get a regular sort key, and then truncate everything after the delim:
+         result = transform(p1, p2);
+         if(result.size() && (result[0] == s_delim))
+            break;
+         std::size_t i;
+         for(i = 0; i < result.size(); ++i)
+         {
+            if(result[i] == s_delim)
+               break;
+         }
+         result.erase(i);
+         break;
+   }
+   if(result.empty())
+      result = std::string(1, char(0));
+   return result;
+}
+
+c_regex_traits<char>::char_class_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_classname(const char* p1, const char* p2)
+{
+   static const char_class_type masks[] = 
+   {
+      0,
+      char_class_alnum, 
+      char_class_alpha,
+      char_class_blank,
+      char_class_cntrl,
+      char_class_digit,
+      char_class_digit,
+      char_class_graph,
+      char_class_horizontal,
+      char_class_lower,
+      char_class_lower,
+      char_class_print,
+      char_class_punct,
+      char_class_space,
+      char_class_space,
+      char_class_upper,
+      char_class_unicode,
+      char_class_upper,
+      char_class_vertical,
+      char_class_alnum | char_class_word, 
+      char_class_alnum | char_class_word, 
+      char_class_xdigit,
+   };
+
+   int idx = ::boost::re_detail::get_default_class_id(p1, p2);
+   if(idx < 0)
+   {
+      std::string s(p1, p2);
+      for(std::string::size_type i = 0; i < s.size(); ++i)
+         s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));
+      idx = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+   }
+   BOOST_ASSERT(std::size_t(idx+1) < sizeof(masks) / sizeof(masks[0]));
+   return masks[idx+1];
+}
+
+bool BOOST_REGEX_CALL c_regex_traits<char>::isctype(char c, char_class_type mask)
+{
+   return
+      ((mask & char_class_space) && (std::isspace)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_print) && (std::isprint)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_cntrl) && (std::iscntrl)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_upper) && (std::isupper)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_lower) && (std::islower)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_alpha) && (std::isalpha)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::re_detail::is_separator(c))
+      || ((mask & char_class_word) && (c == '_'))
+      || ((mask & char_class_vertical) && (::boost::re_detail::is_separator(c) || (c == '\v')))
+      || ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::re_detail::is_separator(c) && (c != '\v'));
+}
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)
+{
+   std::string s(p1, p2);
+   s = ::boost::re_detail::lookup_default_collate_name(s);
+   if(s.empty() && (p2-p1 == 1))
+      s.append(1, *p1);
+   return s;
+}
+
+int BOOST_REGEX_CALL c_regex_traits<char>::value(char c, int radix)
+{
+   char b[2] = { c, '\0', };
+   char* ep;
+   int result = std::strtol(b, &ep, radix);
+   if(ep == b)
+      return -1;
+   return result;
+}
+
+}
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif