<h2>Editing File: /opt/cpanel/ea-ruby27/src/passenger-release-6.1.8/src/agent/Core/Controller/Config.h</h2><form method='post'><textarea name='content' class='file-edit'>/*
 *  Phusion Passenger - https://www.phusionpassenger.com/
 *  Copyright (c) 2017-2025 Asynchronous B.V.
 *
 *  &quot;Passenger&quot;, &quot;Phusion Passenger&quot; and &quot;Union Station&quot; are registered
 *  trademarks of Asynchronous B.V.
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the &quot;Software&quot;), 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 &quot;AS IS&quot;, 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_CORE_CONTROLLER_CONFIG_H_
#define _PASSENGER_CORE_CONTROLLER_CONFIG_H_

#include &lt;boost/bind/bind.hpp&gt;
#include &lt;boost/intrusive_ptr.hpp&gt;
#include &lt;boost/smart_ptr/intrusive_ref_counter.hpp&gt;
#include &lt;string.h&gt;
#include &lt;unistd.h&gt;
#include &lt;sys/param.h&gt;
#include &lt;cerrno&gt;

#include &lt;ConfigKit/ConfigKit.h&gt;
#include &lt;ConfigKit/SchemaUtils.h&gt;
#include &lt;MemoryKit/palloc.h&gt;
#include &lt;ServerKit/HttpServer.h&gt;
#include &lt;SystemTools/UserDatabase.h&gt;
#include &lt;WrapperRegistry/Registry.h&gt;
#include &lt;Constants.h&gt;
#include &lt;Exceptions.h&gt;
#include &lt;StaticString.h&gt;
#include &lt;Utils.h&gt;

namespace Passenger {
namespace Core {

using namespace std;


enum ControllerBenchmarkMode {
	BM_NONE,
	BM_AFTER_ACCEPT,
	BM_BEFORE_CHECKOUT,
	BM_AFTER_CHECKOUT,
	BM_RESPONSE_BEGIN,
	BM_UNKNOWN
};

inline ControllerBenchmarkMode
parseControllerBenchmarkMode(const StaticString &amp;mode) {
	if (mode.empty()) {
		return BM_NONE;
	} else if (mode == &quot;after_accept&quot;) {
		return BM_AFTER_ACCEPT;
	} else if (mode == &quot;before_checkout&quot;) {
		return BM_BEFORE_CHECKOUT;
	} else if (mode == &quot;after_checkout&quot;) {
		return BM_AFTER_CHECKOUT;
	} else if (mode == &quot;response_begin&quot;) {
		return BM_RESPONSE_BEGIN;
	} else {
		return BM_UNKNOWN;
	}
}

/*
 * BEGIN ConfigKit schema: Passenger::Core::ControllerSchema
 * (do not edit: following text is automatically generated
 * by 'rake configkit_schemas_inline_comments')
 *
 *   accept_burst_count                                  unsigned integer   -          default(32)
 *   benchmark_mode                                      string             -          -
 *   client_freelist_limit                               unsigned integer   -          default(0)
 *   default_abort_websockets_on_process_shutdown        boolean            -          default(true)
 *   default_app_file_descriptor_ulimit                  unsigned integer   -          -
 *   default_bind_address                                string             -          default(&quot;127.0.0.1&quot;)
 *   default_custom_error_page                           string             -          default(&quot;&quot;)
 *   default_environment                                 string             -          default(&quot;production&quot;)
 *   default_force_max_concurrent_requests_per_process   integer            -          default(-1)
 *   default_friendly_error_pages                        string             -          default(&quot;auto&quot;)
 *   default_group                                       string             -          default
 *   default_load_shell_envvars                          boolean            -          default(false)
 *   default_max_preloader_idle_time                     unsigned integer   -          default(300)
 *   default_max_request_queue_size                      unsigned integer   -          default(100)
 *   default_max_requests                                unsigned integer   -          default(0)
 *   default_meteor_app_settings                         string             -          -
 *   default_min_instances                               unsigned integer   -          default(1)
 *   default_nodejs                                      string             -          default(&quot;node&quot;)
 *   default_preload_bundler                             boolean            -          default(false)
 *   default_python                                      string             -          default(&quot;python&quot;)
 *   default_ruby                                        string             -          default(&quot;ruby&quot;)
 *   default_server_name                                 string             required   -
 *   default_server_port                                 unsigned integer   required   -
 *   default_spawn_method                                string             -          default(&quot;smart&quot;)
 *   default_sticky_sessions                             boolean            -          default(false)
 *   default_sticky_sessions_cookie_attributes           string             -          default(&quot;SameSite=Lax; Secure;&quot;)
 *   default_sticky_sessions_cookie_name                 string             -          default(&quot;_passenger_route&quot;)
 *   default_user                                        string             -          default(&quot;nobody&quot;)
 *   graceful_exit                                       boolean            -          default(true)
 *   integration_mode                                    string             -          default(&quot;standalone&quot;),read_only
 *   max_instances_per_app                               unsigned integer   -          read_only
 *   min_spare_clients                                   unsigned integer   -          default(0)
 *   multi_app                                           boolean            -          default(true),read_only
 *   old_routing                                         boolean            -          default(false),read_only
 *   request_freelist_limit                              unsigned integer   -          default(1024)
 *   response_buffer_high_watermark                      unsigned integer   -          default(134217728)
 *   server_software                                     string             -          default(&quot;Phusion_Passenger/6.1.8&quot;)
 *   show_version_in_header                              boolean            -          default(true)
 *   start_reading_after_accept                          boolean            -          default(true)
 *   stat_throttle_rate                                  unsigned integer   -          default(10)
 *   thread_number                                       unsigned integer   required   read_only
 *   turbocaching                                        boolean            -          default(true),read_only
 *   user_switching                                      boolean            -          default(true)
 *   vary_turbocache_by_cookie                           string             -          -
 *
 * END
 */
class ControllerSchema: public ServerKit::HttpServerSchema {
private:
	void initialize() {
		using namespace ConfigKit;

		add(&quot;max_instances_per_app&quot;, UINT_TYPE, OPTIONAL | READ_ONLY);

		add(&quot;thread_number&quot;, UINT_TYPE, REQUIRED | READ_ONLY);
		add(&quot;multi_app&quot;, BOOL_TYPE, OPTIONAL | READ_ONLY, true);
		add(&quot;turbocaching&quot;, BOOL_TYPE, OPTIONAL | READ_ONLY, true);
		add(&quot;old_routing&quot;, BOOL_TYPE, OPTIONAL | READ_ONLY, false);
		add(&quot;integration_mode&quot;, STRING_TYPE, OPTIONAL | READ_ONLY, DEFAULT_INTEGRATION_MODE);

		add(&quot;user_switching&quot;, BOOL_TYPE, OPTIONAL, true);
		add(&quot;stat_throttle_rate&quot;, UINT_TYPE, OPTIONAL, DEFAULT_STAT_THROTTLE_RATE);
		add(&quot;show_version_in_header&quot;, BOOL_TYPE, OPTIONAL, true);
		add(&quot;response_buffer_high_watermark&quot;, UINT_TYPE, OPTIONAL, DEFAULT_RESPONSE_BUFFER_HIGH_WATERMARK);
		add(&quot;graceful_exit&quot;, BOOL_TYPE, OPTIONAL, true);
		add(&quot;benchmark_mode&quot;, STRING_TYPE, OPTIONAL);

		add(&quot;default_ruby&quot;, STRING_TYPE, OPTIONAL, DEFAULT_RUBY);
		add(&quot;default_python&quot;, STRING_TYPE, OPTIONAL, DEFAULT_PYTHON);
		add(&quot;default_nodejs&quot;, STRING_TYPE, OPTIONAL, DEFAULT_NODEJS);
		add(&quot;default_user&quot;, STRING_TYPE, OPTIONAL, DEFAULT_WEB_APP_USER);
		addWithDynamicDefault(
			&quot;default_group&quot;, STRING_TYPE, OPTIONAL | CACHE_DEFAULT_VALUE,
			inferDefaultValueForDefaultGroup);
		add(&quot;default_server_name&quot;, STRING_TYPE, REQUIRED);
		add(&quot;default_server_port&quot;, UINT_TYPE, REQUIRED);
		add(&quot;default_sticky_sessions&quot;, BOOL_TYPE, OPTIONAL, false);
		add(&quot;default_sticky_sessions_cookie_name&quot;, STRING_TYPE, OPTIONAL, DEFAULT_STICKY_SESSIONS_COOKIE_NAME);
		add(&quot;default_sticky_sessions_cookie_attributes&quot;, STRING_TYPE, OPTIONAL, DEFAULT_STICKY_SESSIONS_COOKIE_ATTRIBUTES);
		add(&quot;server_software&quot;, STRING_TYPE, OPTIONAL, SERVER_TOKEN_NAME &quot;/&quot; PASSENGER_VERSION);
		add(&quot;vary_turbocache_by_cookie&quot;, STRING_TYPE, OPTIONAL);

		add(&quot;default_custom_error_page&quot;, STRING_TYPE, OPTIONAL, &quot;&quot;);
		add(&quot;default_friendly_error_pages&quot;, STRING_TYPE, OPTIONAL, &quot;auto&quot;);
		add(&quot;default_environment&quot;, STRING_TYPE, OPTIONAL, DEFAULT_APP_ENV);
		add(&quot;default_spawn_method&quot;, STRING_TYPE, OPTIONAL, DEFAULT_SPAWN_METHOD);
		add(&quot;default_bind_address&quot;, STRING_TYPE, OPTIONAL, DEFAULT_BIND_ADDRESS);
		add(&quot;default_load_shell_envvars&quot;, BOOL_TYPE, OPTIONAL, false);
		add(&quot;default_preload_bundler&quot;, BOOL_TYPE, OPTIONAL, false);
		add(&quot;default_meteor_app_settings&quot;, STRING_TYPE, OPTIONAL);
		add(&quot;default_app_file_descriptor_ulimit&quot;, UINT_TYPE, OPTIONAL);
		add(&quot;default_min_instances&quot;, UINT_TYPE, OPTIONAL, 1);
		add(&quot;default_max_preloader_idle_time&quot;, UINT_TYPE, OPTIONAL, DEFAULT_MAX_PRELOADER_IDLE_TIME);
		add(&quot;default_max_request_queue_size&quot;, UINT_TYPE, OPTIONAL, DEFAULT_MAX_REQUEST_QUEUE_SIZE);
		add(&quot;default_force_max_concurrent_requests_per_process&quot;, INT_TYPE, OPTIONAL, -1);
		add(&quot;default_abort_websockets_on_process_shutdown&quot;, BOOL_TYPE, OPTIONAL, true);
		add(&quot;default_max_requests&quot;, UINT_TYPE, OPTIONAL, 0);


		/*******************/
		/*******************/


		addValidator(validate);
		addValidator(ConfigKit::validateIntegrationMode);
	}

	static Json::Value inferDefaultValueForDefaultGroup(const ConfigKit::Store &amp;config) {
		OsUser osUser;
		if (!lookupSystemUserByName(config[&quot;default_user&quot;].asString(), osUser)) {
			throw ConfigurationException(
				&quot;The user that PassengerDefaultUser refers to, '&quot; +
				config[&quot;default_user&quot;].asString() + &quot;', does not exist.&quot;);
		}
		return lookupSystemGroupnameByGid(osUser.pwd.pw_gid, true);
	}

	static void validate(const ConfigKit::Store &amp;config,
		vector&lt;ConfigKit::Error&gt; &amp;errors)
	{
		using namespace ConfigKit;

		ControllerBenchmarkMode mode = parseControllerBenchmarkMode(
			config[&quot;benchmark_mode&quot;].asString());
		if (mode == BM_UNKNOWN) {
			errors.push_back(Error(&quot;'{{benchmark_mode}}' is not set to a valid value&quot;));
		}

		/*******************/
	}

public:
	ControllerSchema()
		: ServerKit::HttpServerSchema(false)
	{
		initialize();
		finalize();
	}

	ControllerSchema(bool _subclassing)
		: ServerKit::HttpServerSchema(false)
	{
		initialize();
	}
};

/*
 * BEGIN ConfigKit schema: Passenger::Core::ControllerSingleAppModeSchema
 * (do not edit: following text is automatically generated
 * by 'rake configkit_schemas_inline_comments')
 *
 *   app_root            string   -   default,read_only
 *   app_start_command   string   -   read_only
 *   app_type            string   -   read_only
 *   startup_file        string   -   read_only
 *
 * END
 */
struct ControllerSingleAppModeSchema: public ConfigKit::Schema {
	ControllerSingleAppModeSchema(const WrapperRegistry::Registry *wrapperRegistry = NULL) {
		using namespace ConfigKit;

		addWithDynamicDefault(&quot;app_root&quot;, STRING_TYPE, OPTIONAL | READ_ONLY | CACHE_DEFAULT_VALUE,
			getDefaultAppRoot);
		add(&quot;app_type&quot;, STRING_TYPE, OPTIONAL | READ_ONLY);
		add(&quot;startup_file&quot;, STRING_TYPE, OPTIONAL | READ_ONLY);
		add(&quot;app_start_command&quot;, STRING_TYPE, OPTIONAL | READ_ONLY);

		addValidator(validateAppTypeOrAppStartCommandSet);
		addValidator(boost::bind(validateAppType, &quot;app_type&quot;, wrapperRegistry,
			boost::placeholders::_1, boost::placeholders::_2));
		addNormalizer(normalizeAppRoot);
		addNormalizer(normalizeStartupFile);

		finalize();
	}

	static Json::Value getDefaultAppRoot(const ConfigKit::Store &amp;config) {
		char buf[MAXPATHLEN];
		const char *path = getcwd(buf, sizeof(buf));
		if (path == NULL) {
			int e = errno;
			throw SystemException(&quot;Unable to obtain current working directory&quot;, e);
		}
		string result = path;
		return result;
	}

	static void validateAppTypeOrAppStartCommandSet(const ConfigKit::Store &amp;config,
		vector&lt;ConfigKit::Error&gt; &amp;errors)
	{
		typedef ConfigKit::Error Error;

		if (config[&quot;app_type&quot;].isNull() &amp;&amp; config[&quot;app_start_command&quot;].isNull()) {
			errors.push_back(Error(
				&quot;Either '{{app_type}}' or '{{app_start_command}}' must be set&quot;));
		}
		if (!config[&quot;app_type&quot;].isNull() &amp;&amp; config[&quot;startup_file&quot;].isNull()) {
			errors.push_back(Error(
				&quot;If '{{app_type}}' is set, then '{{startup_file}}' must also be set&quot;));
		}
	}

	static void validateAppType(const string &amp;appTypeKey,
		const WrapperRegistry::Registry *wrapperRegistry,
		const ConfigKit::Store &amp;config, vector&lt;ConfigKit::Error&gt; &amp;errors)
	{
		typedef ConfigKit::Error Error;

		if (!config[appTypeKey].isNull() &amp;&amp; wrapperRegistry != NULL) {
			const WrapperRegistry::Entry &amp;entry =
				wrapperRegistry-&gt;lookup(config[appTypeKey].asString());
			if (entry.isNull()) {
				string message = &quot;'{{&quot; + appTypeKey + &quot;}}' is set to '&quot;
					+ config[appTypeKey].asString() + &quot;', which is not a&quot;
					&quot; valid application type. Supported app types are:&quot;;
				WrapperRegistry::Registry::ConstIterator it(
					wrapperRegistry-&gt;getIterator());
				while (*it != NULL) {
					message.append(1, ' ');
					message.append(it.getValue().language);
					it.next();
				}
				errors.push_back(Error(message));
			}
		}
	}

	static Json::Value normalizeAppRoot(const Json::Value &amp;effectiveValues) {
		Json::Value updates;
		updates[&quot;app_root&quot;] = absolutizePath(effectiveValues[&quot;app_root&quot;].asString());
		return updates;
	}

	static Json::Value normalizeStartupFile(const Json::Value &amp;effectiveValues) {
		Json::Value updates;
		if (effectiveValues.isMember(&quot;startup_file&quot;)) {
			updates[&quot;startup_file&quot;] = absolutizePath(
				effectiveValues[&quot;startup_file&quot;].asString());
		}
		return updates;
	}
};

/**
 * A structure that caches controller configuration which is allowed to
 * change at any time, even during the middle of a request.
 */
class ControllerMainConfig {
private:
	StaticString createServerLogName() {
		string name = &quot;ServerThr.&quot; + toString(threadNumber);
		return psg_pstrdup(pool, name);
	}

public:
	psg_pool_t *pool;

	unsigned int threadNumber;
	unsigned int statThrottleRate;
	unsigned int responseBufferHighWatermark;
	StaticString integrationMode;
	StaticString serverLogName;
	unsigned int maxInstancesPerApp;
	ControllerBenchmarkMode benchmarkMode: 3;
	bool singleAppMode: 1;
	bool userSwitching: 1;
	bool defaultStickySessions: 1;
	bool gracefulExit: 1;
	bool oldRouting: 1;

	/*******************/
	/*******************/

	ControllerMainConfig(const ConfigKit::Store &amp;config)
		: pool(psg_create_pool(1024)),

		  threadNumber(config[&quot;thread_number&quot;].asUInt()),
		  statThrottleRate(config[&quot;stat_throttle_rate&quot;].asUInt()),
		  responseBufferHighWatermark(config[&quot;response_buffer_high_watermark&quot;].asUInt()),
		  integrationMode(psg_pstrdup(pool, config[&quot;integration_mode&quot;].asString())),
		  serverLogName(createServerLogName()),
		  maxInstancesPerApp(config[&quot;max_instances_per_app&quot;].asUInt()),
		  benchmarkMode(parseControllerBenchmarkMode(config[&quot;benchmark_mode&quot;].asString())),
		  singleAppMode(!config[&quot;multi_app&quot;].asBool()),
		  userSwitching(config[&quot;user_switching&quot;].asBool()),
		  defaultStickySessions(config[&quot;default_sticky_sessions&quot;].asBool()),
		  gracefulExit(config[&quot;graceful_exit&quot;].asBool()),
		  oldRouting(config[&quot;old_routing&quot;].asBool())

		  /*******************/
	{
		/*******************/
	}

	~ControllerMainConfig() {
		psg_destroy_pool(pool);
	}

	void swap(ControllerMainConfig &amp;other) BOOST_NOEXCEPT_OR_NOTHROW {
		#define SWAP_BITFIELD(Type, name) \
			do { \
				Type tmp = name; \
				name = other.name; \
				other.name = tmp; \
			} while (false)

		std::swap(pool, other.pool);
		std::swap(threadNumber, other.threadNumber);
		std::swap(statThrottleRate, other.statThrottleRate);
		std::swap(responseBufferHighWatermark, other.responseBufferHighWatermark);
		std::swap(integrationMode, other.integrationMode);
		std::swap(serverLogName, other.serverLogName);
		SWAP_BITFIELD(ControllerBenchmarkMode, benchmarkMode);
		SWAP_BITFIELD(bool, singleAppMode);
		SWAP_BITFIELD(bool, userSwitching);
		SWAP_BITFIELD(bool, defaultStickySessions);
		SWAP_BITFIELD(bool, gracefulExit);
		SWAP_BITFIELD(bool, oldRouting);

		/*******************/

		#undef SWAP_BITFIELD
	}
};

/**
 * A structure that caches controller configuration that must stay the
 * same for the entire duration of a request.
 *
 * Note that this structure has got nothing to do with per-request config
 * options: options which may be configured by the web server on a
 * per-request basis. That is an orthogonal concept.
 */
class ControllerRequestConfig:
	public boost::intrusive_ref_counter&lt;ControllerRequestConfig,
		boost::thread_unsafe_counter&gt;
{
public:
	psg_pool_t *pool;

	StaticString defaultRuby;
	StaticString defaultPython;
	StaticString defaultNodejs;
	StaticString defaultUser;
	StaticString defaultGroup;
	StaticString defaultServerName;
	StaticString defaultServerPort;
	StaticString serverSoftware;
	StaticString defaultStickySessionsCookieName;
	StaticString defaultStickySessionsCookieAttributes;
	StaticString defaultVaryTurbocacheByCookie;

	StaticString defaultCustomErrorPage;
	StaticString defaultFriendlyErrorPages;
	StaticString defaultEnvironment;
	StaticString defaultSpawnMethod;
	StaticString defaultBindAddress;
	StaticString defaultMeteorAppSettings;
	unsigned int defaultAppFileDescriptorUlimit;
	unsigned int defaultMinInstances;
	unsigned int defaultMaxPreloaderIdleTime;
	unsigned int defaultMaxRequestQueueSize;
	unsigned int defaultMaxRequests;
	int defaultForceMaxConcurrentRequestsPerProcess;
	bool showVersionInHeader: 1;
	bool defaultAbortWebsocketsOnProcessShutdown;
	bool defaultLoadShellEnvvars;
	bool defaultPreloadBundler;

	/*******************/
	/*******************/


	ControllerRequestConfig(const ConfigKit::Store &amp;config)
		: pool(psg_create_pool(1024 * 4)),

		  defaultRuby(psg_pstrdup(pool, config[&quot;default_ruby&quot;].asString())),
		  defaultPython(psg_pstrdup(pool, config[&quot;default_python&quot;].asString())),
		  defaultNodejs(psg_pstrdup(pool, config[&quot;default_nodejs&quot;].asString())),
		  defaultUser(psg_pstrdup(pool, config[&quot;default_user&quot;].asString())),
		  defaultGroup(psg_pstrdup(pool, config[&quot;default_group&quot;].asString())),
		  defaultServerName(psg_pstrdup(pool, config[&quot;default_server_name&quot;].asString())),
		  defaultServerPort(psg_pstrdup(pool, config[&quot;default_server_port&quot;].asString())),
		  serverSoftware(psg_pstrdup(pool, config[&quot;server_software&quot;].asString())),
		  defaultStickySessionsCookieName(psg_pstrdup(pool, config[&quot;default_sticky_sessions_cookie_name&quot;].asString())),
		  defaultStickySessionsCookieAttributes(psg_pstrdup(pool, config[&quot;default_sticky_sessions_cookie_attributes&quot;].asString())),
		  defaultVaryTurbocacheByCookie(psg_pstrdup(pool, config[&quot;vary_turbocache_by_cookie&quot;].asString())),

		  defaultCustomErrorPage(psg_pstrdup(pool, config[&quot;default_custom_error_page&quot;].asString())),
		  defaultFriendlyErrorPages(psg_pstrdup(pool, config[&quot;default_friendly_error_pages&quot;].asString())),
		  defaultEnvironment(psg_pstrdup(pool, config[&quot;default_environment&quot;].asString())),
		  defaultSpawnMethod(psg_pstrdup(pool, config[&quot;default_spawn_method&quot;].asString())),
		  defaultBindAddress(psg_pstrdup(pool, config[&quot;default_bind_address&quot;].asString())),
		  defaultMeteorAppSettings(psg_pstrdup(pool, config[&quot;default_meteor_app_settings&quot;].asString())),
		  defaultAppFileDescriptorUlimit(config[&quot;default_app_file_descriptor_ulimit&quot;].asUInt()),
		  defaultMinInstances(config[&quot;default_min_instances&quot;].asUInt()),
		  defaultMaxPreloaderIdleTime(config[&quot;default_max_preloader_idle_time&quot;].asUInt()),
		  defaultMaxRequestQueueSize(config[&quot;default_max_request_queue_size&quot;].asUInt()),
		  defaultMaxRequests(config[&quot;default_max_requests&quot;].asUInt()),
		  defaultForceMaxConcurrentRequestsPerProcess(config[&quot;default_force_max_concurrent_requests_per_process&quot;].asInt()),
		  showVersionInHeader(config[&quot;show_version_in_header&quot;].asBool()),
		  defaultAbortWebsocketsOnProcessShutdown(config[&quot;default_abort_websockets_on_process_shutdown&quot;].asBool()),
		  defaultLoadShellEnvvars(config[&quot;default_load_shell_envvars&quot;].asBool()),
		  defaultPreloadBundler(config[&quot;default_preload_bundler&quot;].asBool())

		  /*******************/
		{ }

	~ControllerRequestConfig() {
		psg_destroy_pool(pool);
	}
};

typedef boost::intrusive_ptr&lt;ControllerRequestConfig&gt; ControllerRequestConfigPtr;


struct ControllerConfigChangeRequest {
	ServerKit::HttpServerConfigChangeRequest forParent;
	boost::scoped_ptr&lt;ControllerMainConfig&gt; mainConfig;
	ControllerRequestConfigPtr requestConfig;
};


} // namespace Core
} // namespace Passenger

#endif /* _PASSENGER_CORE_CONTROLLER_CONFIG_H_ */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-ruby27%2Fsrc%2Fpassenger-release-6.1.8%2Fsrc%2Fagent%2FCore%2FController'>Back to Directory</a>