passenger 4.0.14 → 4.0.16

data/ext/common/Utils/StrIntUtils.h

@@ -237,6 +237,11 @@ integerToHexatri(IntegerType value, char *output) {
  */
 string integerToHexatri(long long value);
 
+/**
+ * Checks whether the given string looks like a number >= 0.
+ */
+bool looksLikePositiveNumber(const StaticString &str);
+
 /**
  * Converts the given string to an integer.
  */

data/ext/common/agents/HelperAgent/Main.cpp

@@ -329,8 +329,8 @@ private:
 	 */
 	void lowerPrivilege(const string &username, const string &groupname) {
 		struct passwd *userEntry;
-		struct group  *groupEntry;
-		int            e;
+		gid_t gid;
+		int e;
 		
 		userEntry = getpwnam(username.c_str());
 		if (userEntry == NULL) {
@@ -338,8 +338,8 @@ private:
 				"HelperAgent's privilege to that of user '") + username +
 				"': user does not exist.");
 		}
-		groupEntry = getgrnam(groupname.c_str());
-		if (groupEntry == NULL) {
+		gid = lookupGid(groupname);
+		if (gid == (gid_t) -1) {
 			throw NonExistentGroupException(string("Unable to lower Passenger "
 				"HelperAgent's privilege to that of user '") + username +
 				"': user does not exist.");
@@ -351,7 +351,7 @@ private:
 				"privilege to that of user '") + username +
 				"': cannot set supplementary groups for this user", e);
 		}
-		if (setgid(groupEntry->gr_gid) != 0) {
+		if (setgid(gid) != 0) {
 			e = errno;
 			throw SystemException(string("Unable to lower Passenger HelperAgent's "
 				"privilege to that of user '") + username +

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -120,6 +120,7 @@ using namespace ApplicationPool2;
 
 class RequestHandler;
 
+#define RH_ERROR(client, x) P_ERROR("[Client " << client->name() << "] " << x)
 #define RH_WARN(client, x) P_WARN("[Client " << client->name() << "] " << x)
 #define RH_DEBUG(client, x) P_DEBUG("[Client " << client->name() << "] " << x)
 #define RH_TRACE(client, level, x) P_TRACE(level, "[Client " << client->name() << "] " << x)
@@ -651,28 +652,38 @@ private:
 		}
 	}
 
-	void writeSimpleResponse(const ClientPtr &client, const StaticString &data) {
-		char header[256];
+	void writeSimpleResponse(const ClientPtr &client, const StaticString &data, int code = 200) {
+		char header[256], statusBuffer[50];
 		char *pos = header;
 		const char *end = header + sizeof(header) - 1;
+		const char *status;
+
+		status = getStatusCodeAndReasonPhrase(code);
+		if (status == NULL) {
+			snprintf(statusBuffer, sizeof(statusBuffer), "%d Unknown Reason-Phrase", code);
+			status = statusBuffer;
+		}
 
 		if (getBoolOption(client, "PASSENGER_STATUS_LINE", true)) {
-			pos = appendData(pos, end, "HTTP/1.1 200 OK\r\n");
+			pos += snprintf(pos, end - pos, "HTTP/1.1 %s\r\n",
+				status);
 		}
 		pos += snprintf(pos, end - pos,
-			"Status: 200 OK\r\n"
+			"Status: %s\r\n"
 			"Content-Length: %lu\r\n"
 			"Content-Type: text/html; charset=UTF-8\r\n"
 			"Cache-Control: no-cache, no-store, must-revalidate\r\n"
 			"\r\n",
-			(unsigned long) data.size());
+			status, (unsigned long) data.size());
 
 		client->clientOutputPipe->write(header, pos - header);
 		client->clientOutputPipe->write(data.data(), data.size());
 		client->clientOutputPipe->end();
 
 		if (client->useUnionStation()) {
-			client->logMessage("Status: 200 OK");
+			snprintf(header, end - header, "Status: %d %s",
+				code, status);
+			client->logMessage(header);
 		}
 	}
 
@@ -1621,6 +1632,13 @@ private:
 		}
 	}
 
+	static void fillPoolOptionSecToMsec(const ClientPtr &client, unsigned int &field, const StaticString &name) {
+		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
+		if (it != client->scgiParser.end()) {
+			field = stringToUint(it->second) * 1000;
+		}
+	}
+
 	void fillPoolOptions(const ClientPtr &client) {
 		Options &options = client->options;
 		ScgiRequestParser &parser = client->scgiParser;
@@ -1670,8 +1688,9 @@ private:
 		fillPoolOption(client, options.maxRequests, "PASSENGER_MAX_REQUESTS");
 		fillPoolOption(client, options.spawnMethod, "PASSENGER_SPAWN_METHOD");
 		fillPoolOption(client, options.startCommand, "PASSENGER_START_COMMAND");
-		fillPoolOption(client, options.startTimeout, "PASSENGER_START_TIMEOUT");
+		fillPoolOptionSecToMsec(client, options.startTimeout, "PASSENGER_START_TIMEOUT");
 		fillPoolOption(client, options.maxPreloaderIdleTime, "PASSENGER_MAX_PRELOADER_IDLE_TIME");
+		fillPoolOption(client, options.maxRequestQueueSize, "PASSENGER_MAX_REQUEST_QUEUE_SIZE");
 		fillPoolOption(client, options.statThrottleRate, "PASSENGER_STAT_THROTTLE_RATE");
 		fillPoolOption(client, options.restartDir, "PASSENGER_RESTART_DIR");
 		fillPoolOption(client, options.loadShellEnvvars, "PASSENGER_LOAD_SHELL_ENVVARS");
@@ -1890,47 +1909,21 @@ private:
 
 		if (e != NULL) {
 			client->endScopeLog(&client->scopeLogs.getFromPool, false);
-			shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
-			if (e2 != NULL) {
-				if (strip(e2->getErrorPage()).empty()) {
-					RH_WARN(client, "Cannot checkout session. " << e2->what());
-					writeErrorResponse(client, e2->what());
-				} else {
-					RH_WARN(client, "Cannot checkout session. " << e2->what() <<
-						"\nError page:\n" << e2->getErrorPage());
-					writeErrorResponse(client, e2->getErrorPage(), e2.get());
+			{
+				shared_ptr<RequestQueueFullException> e2 = dynamic_pointer_cast<RequestQueueFullException>(e);
+				if (e2 != NULL) {
+					writeRequestQueueFullExceptionErrorResponse(client);
+					return;
 				}
-			} else {
-				string typeName;
-				#ifdef CXX_ABI_API_AVAILABLE
-					int status;
-					char *tmp = abi::__cxa_demangle(typeid(*e).name(), 0, 0, &status);
-					if (tmp != NULL) {
-						typeName = tmp;
-						free(tmp);
-					} else {
-						typeName = typeid(*e).name();
-					}
-				#else
-					typeName = typeid(*e).name();
-				#endif
-
-				RH_WARN(client, "Cannot checkout session (exception type " <<
-					typeName << "): " << e->what());
-				
-				string response = "An internal error occurred while trying to spawn the application.\n";
-				response.append("Exception type: ");
-				response.append(typeName);
-				response.append("\nError message: ");
-				response.append(e->what());
-				shared_ptr<tracable_exception> e3 = dynamic_pointer_cast<tracable_exception>(e);
-				if (e3 != NULL) {
-					response.append("\nBacktrace:\n");
-					response.append(e3->backtrace());
+			}
+			{
+				shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
+				if (e2 != NULL) {
+					writeSpawnExceptionErrorResponse(client, e2);
+					return;
 				}
-
-				writeErrorResponse(client, response);
 			}
+			writeOtherExceptionErrorResponse(client, e);
 		} else {
 			RH_DEBUG(client, "Session checked out: pid=" << session->getPid() <<
 				", gupid=" << session->getGupid());
@@ -1939,6 +1932,62 @@ private:
 		}
 	}
 
+	void writeRequestQueueFullExceptionErrorResponse(const ClientPtr &client) {
+		StaticString value = client->scgiParser.getHeader("PASSENGER_REQUEST_QUEUE_OVERFLOW_STATUS_CODE");
+		int requestQueueOverflowStatusCode = 503;
+		if (!value.empty()) {
+			requestQueueOverflowStatusCode = atoi(value.data());
+		}
+		writeSimpleResponse(client,
+			"<h1>This website is under heavy load</h1>"
+			"<p>We're sorry, too many people are accessing this website at the same "
+			"time. We're working on this problem. Please try again later.</p>",
+			requestQueueOverflowStatusCode);
+	}
+
+	void writeSpawnExceptionErrorResponse(const ClientPtr &client, const shared_ptr<SpawnException> &e) {
+		if (strip(e->getErrorPage()).empty()) {
+			RH_WARN(client, "Cannot checkout session. " << e->what());
+			writeErrorResponse(client, e->what());
+		} else {
+			RH_WARN(client, "Cannot checkout session. " << e->what() <<
+				"\nError page:\n" << e->getErrorPage());
+			writeErrorResponse(client, e->getErrorPage(), e.get());
+		}
+	}
+
+	void writeOtherExceptionErrorResponse(const ClientPtr &client, const ExceptionPtr &e) {
+		string typeName;
+		#ifdef CXX_ABI_API_AVAILABLE
+			int status;
+			char *tmp = abi::__cxa_demangle(typeid(*e).name(), 0, 0, &status);
+			if (tmp != NULL) {
+				typeName = tmp;
+				free(tmp);
+			} else {
+				typeName = typeid(*e).name();
+			}
+		#else
+			typeName = typeid(*e).name();
+		#endif
+
+		RH_WARN(client, "Cannot checkout session (exception type " <<
+			typeName << "): " << e->what());
+		
+		string response = "An internal error occurred while trying to spawn the application.\n";
+		response.append("Exception type: ");
+		response.append(typeName);
+		response.append("\nError message: ");
+		response.append(e->what());
+		shared_ptr<tracable_exception> e3 = dynamic_pointer_cast<tracable_exception>(e);
+		if (e3 != NULL) {
+			response.append("\nBacktrace:\n");
+			response.append(e3->backtrace());
+		}
+
+		writeErrorResponse(client, response);
+	}
+
 	void initiateSession(const ClientPtr &client) {
 		assert(client->state == Client::CHECKING_OUT_SESSION);
 		client->sessionCheckoutTry++;

data/ext/common/agents/LoggingAgent/Main.cpp

@@ -182,19 +182,19 @@ initializePrivilegedWorkingObjects(WorkingObjects &wo) {
 }
 
 static void
-lowerPrivilege(const string &username, const struct passwd *user, const struct group *group) {
+lowerPrivilege(const string &username, const struct passwd *user, gid_t gid) {
 	int e;
 	
-	if (initgroups(username.c_str(), group->gr_gid) != 0) {
+	if (initgroups(username.c_str(), gid) != 0) {
 		e = errno;
 		P_WARN("WARNING: Unable to set supplementary groups for " <<
 			"PassengerLoggingAgent: " << strerror(e) << " (" << e << ")");
 	}
-	if (setgid(group->gr_gid) != 0) {
+	if (setgid(gid) != 0) {
 		e = errno;
 		P_WARN("WARNING: Unable to lower PassengerLoggingAgent's "
 			"privilege to that of user '" << username <<
-			"': cannot set group ID to " << group->gr_gid <<
+			"': cannot set group ID to " << gid <<
 			": " << strerror(e) <<
 			" (" << e << ")");
 	}
@@ -210,7 +210,7 @@ lowerPrivilege(const string &username, const struct passwd *user, const struct g
 static void
 maybeLowerPrivilege() {
 	struct passwd *user;
-	struct group  *group;
+	gid_t gid;
 
 	/* Sanity check user accounts. */
 		
@@ -224,27 +224,11 @@ maybeLowerPrivilege() {
 	}
 	
 	if (groupname.empty()) {
-		group = getgrgid(user->pw_gid);
-		if (group == NULL) {
-			throw NonExistentGroupException(string("The configuration option ") +
-				"'PassengerAnalyticsLogGroup' (Apache) or " +
-				"'passenger_analytics_log_group' (Nginx) wasn't set, " +
-				"so PassengerLoggingAgent tried to use the default group " +
-				"for user '" + username + "' - which is GID #" +
-				toString(user->pw_gid) + " - as the group for the analytics " +
-				"log dir, but this GID doesn't exist. " +
-				"You can solve this problem by explicitly " +
-				"setting PassengerAnalyticsLogGroup (Apache) or " +
-				"passenger_analytics_log_group (Nginx) to a group that " +
-				"does exist. In any case, it looks like your system's user " +
-				"database is broken; Phusion Passenger can work fine even " +
-				"with this broken user database, but you should still fix it.");
-		} else {
-			groupname = group->gr_name;
-		}
+		gid = user->pw_gid;
+		groupname = getGroupName(user->pw_gid);
 	} else {
-		group = getgrnam(groupname.c_str());
-		if (group == NULL) {
+		gid = lookupGid(groupname);
+		if (gid == (gid_t) -1) {
 			throw NonExistentGroupException(string("The configuration option ") +
 				"'PassengerAnalyticsLogGroup' (Apache) or " +
 				"'passenger_analytics_log_group' (Nginx) was set to '" +
@@ -255,7 +239,7 @@ maybeLowerPrivilege() {
 
 	/* Now's a good time to lower the privilege. */
 	if (geteuid() == 0) {
-		lowerPrivilege(username, user, group);
+		lowerPrivilege(username, user, gid);
 	}
 }
 

data/ext/common/agents/Watchdog/Main.cpp

@@ -54,6 +54,7 @@
 #include <Utils/Base64.h>
 #include <Utils/Timer.h>
 #include <Utils/ScopeGuard.h>
+#include <Utils/StrIntUtils.h>
 #include <Utils/IOUtils.h>
 #include <Utils/MessageIO.h>
 #include <Utils/VariantMap.h>
@@ -378,17 +379,7 @@ inferDefaultGroup(const string &defaultUser) {
 			string("The user that PassengerDefaultUser refers to, '") +
 			defaultUser + "', does not exist.");
 	}
-	
-	struct group *groupEntry = getgrgid(userEntry->pw_gid);
-	if (groupEntry == NULL) {
-		throw ConfigurationException(
-			string("The option PassengerDefaultUser is set to '" +
-			defaultUser + "', but its primary group doesn't exist. "
-			"In other words, your system's user account database "
-			"is broken. Please fix it."));
-	}
-	
-	return groupEntry->gr_name;
+	return getGroupName(userEntry->pw_gid);
 }
 
 static void
@@ -477,7 +468,6 @@ maybeSetsid() {
 static void
 lookupDefaultUidGid(uid_t &uid, gid_t &gid) {
 	struct passwd *userEntry;
-	struct group  *groupEntry;
 	
 	userEntry = getpwnam(defaultUser.c_str());
 	if (userEntry == NULL) {
@@ -486,12 +476,11 @@ lookupDefaultUidGid(uid_t &uid, gid_t &gid) {
 	}
 	uid = userEntry->pw_uid;
 
-	groupEntry = getgrnam(defaultGroup.c_str());
-	if (groupEntry == NULL) {
+	gid = lookupGid(defaultGroup);
+	if (gid == (gid_t) -1) {
 		throw NonExistentGroupException("Default group '" + defaultGroup +
 			"' does not exist.");
 	}
-	gid = groupEntry->gr_gid;
 }
 
 static void

data/ext/nginx/CacheLocationConfig.c

@@ -0,0 +1,501 @@
+/*
+ *  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.
+ */
+
+/*
+ * CacheLocationConfig.c is automatically generated from CacheLocationConfig.c.erb,
+ * using definitions from lib/phusion_passenger/nginx/config_options.rb.
+ * Edits to MergeLocationConfig.c will be lost.
+ *
+ * To update CacheLocationConfig.c:
+ *   rake nginx
+ *
+ * To force regeneration of CacheLocationConfig.c:
+ *   rm -f ext/nginx/CacheLocationConfig.c
+ *   rake ext/nginx/CacheLocationConfig.c
+ */
+
+
+
+size_t len = 0;
+u_char int_buf[32], *end, *buf, *pos;
+
+/* Calculate lengths */
+
+	
+		if (conf->ruby.data != NULL) {
+			len += 15;
+			len += conf->ruby.len + 1;
+		}
+	
+
+	
+		if (conf->python.data != NULL) {
+			len += 17;
+			len += conf->python.len + 1;
+		}
+	
+
+	
+		if (conf->environment.data != NULL) {
+			len += 14;
+			len += conf->environment.len + 1;
+		}
+	
+
+	
+		if (conf->friendly_error_pages != NGX_CONF_UNSET) {
+			len += 31;
+			len += conf->friendly_error_pages ? sizeof("true") : sizeof("false");
+		}
+	
+
+	
+		if (conf->min_instances != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->min_instances);
+			len += 24;
+			len += end - int_buf + 1;
+		}
+	
+
+	
+		if (conf->max_requests != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_requests);
+			len += 23;
+			len += end - int_buf + 1;
+		}
+	
+
+	
+		if (conf->start_timeout != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->start_timeout);
+			len += 24;
+			len += end - int_buf + 1;
+		}
+	
+
+	
+		if (conf->user.data != NULL) {
+			len += 15;
+			len += conf->user.len + 1;
+		}
+	
+
+	
+		if (conf->group.data != NULL) {
+			len += 16;
+			len += conf->group.len + 1;
+		}
+	
+
+	
+		if (conf->app_group_name.data != NULL) {
+			len += 25;
+			len += conf->app_group_name.len + 1;
+		}
+	
+
+	
+		if (conf->app_root.data != NULL) {
+			len += 19;
+			len += conf->app_root.len + 1;
+		}
+	
+
+	
+		if (conf->app_rights.data != NULL) {
+			len += 21;
+			len += conf->app_rights.len + 1;
+		}
+	
+
+	
+		if (conf->union_station_support != NGX_CONF_UNSET) {
+			len += 22;
+			len += conf->union_station_support ? sizeof("true") : sizeof("false");
+		}
+	
+
+	
+		if (conf->debugger != NGX_CONF_UNSET) {
+			len += 19;
+			len += conf->debugger ? sizeof("true") : sizeof("false");
+		}
+	
+
+	
+		if (conf->show_version_in_header != NGX_CONF_UNSET) {
+			len += 33;
+			len += conf->show_version_in_header ? sizeof("true") : sizeof("false");
+		}
+	
+
+	
+		if (conf->max_preloader_idle_time != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_preloader_idle_time);
+			len += 34;
+			len += end - int_buf + 1;
+		}
+	
+
+	
+		if (conf->spawn_method.data != NULL) {
+			len += 23;
+			len += conf->spawn_method.len + 1;
+		}
+	
+
+	
+		if (conf->union_station_key.data != NULL) {
+			len += 18;
+			len += conf->union_station_key.len + 1;
+		}
+	
+
+	
+		if (conf->max_request_queue_size != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_request_queue_size);
+			len += 33;
+			len += end - int_buf + 1;
+		}
+	
+
+	
+		if (conf->request_queue_overflow_status_code != NGX_CONF_UNSET) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->request_queue_overflow_status_code);
+			len += 45;
+			len += end - int_buf + 1;
+		}
+	
+
+
+/* Create string */
+buf = pos = ngx_pnalloc(cf->pool, len);
+
+
+	
+		if (conf->ruby.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_RUBY",
+				15);
+			pos = ngx_copy(pos,
+				conf->ruby.data,
+				conf->ruby.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->python.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_PYTHON",
+				17);
+			pos = ngx_copy(pos,
+				conf->python.data,
+				conf->python.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->environment.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_ENV",
+				14);
+			pos = ngx_copy(pos,
+				conf->environment.data,
+				conf->environment.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->friendly_error_pages != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_FRIENDLY_ERROR_PAGES",
+				31);
+			if (conf->friendly_error_pages) {
+				pos = ngx_copy(pos, "true", sizeof("true"));
+			} else {
+				pos = ngx_copy(pos, "false", sizeof("false"));
+			}
+		}
+	
+
+	
+		if (conf->min_instances != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_MIN_INSTANCES",
+				24);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->min_instances);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->max_requests != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_MAX_REQUESTS",
+				23);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_requests);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->start_timeout != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_START_TIMEOUT",
+				24);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->start_timeout);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->user.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_USER",
+				15);
+			pos = ngx_copy(pos,
+				conf->user.data,
+				conf->user.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->group.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_GROUP",
+				16);
+			pos = ngx_copy(pos,
+				conf->group.data,
+				conf->group.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->app_group_name.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_APP_GROUP_NAME",
+				25);
+			pos = ngx_copy(pos,
+				conf->app_group_name.data,
+				conf->app_group_name.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->app_root.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_APP_ROOT",
+				19);
+			pos = ngx_copy(pos,
+				conf->app_root.data,
+				conf->app_root.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->app_rights.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_APP_RIGHTS",
+				21);
+			pos = ngx_copy(pos,
+				conf->app_rights.data,
+				conf->app_rights.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->union_station_support != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"UNION_STATION_SUPPORT",
+				22);
+			if (conf->union_station_support) {
+				pos = ngx_copy(pos, "true", sizeof("true"));
+			} else {
+				pos = ngx_copy(pos, "false", sizeof("false"));
+			}
+		}
+	
+
+	
+		if (conf->debugger != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_DEBUGGER",
+				19);
+			if (conf->debugger) {
+				pos = ngx_copy(pos, "true", sizeof("true"));
+			} else {
+				pos = ngx_copy(pos, "false", sizeof("false"));
+			}
+		}
+	
+
+	
+		if (conf->show_version_in_header != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_SHOW_VERSION_IN_HEADER",
+				33);
+			if (conf->show_version_in_header) {
+				pos = ngx_copy(pos, "true", sizeof("true"));
+			} else {
+				pos = ngx_copy(pos, "false", sizeof("false"));
+			}
+		}
+	
+
+	
+		if (conf->max_preloader_idle_time != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_MAX_PRELOADER_IDLE_TIME",
+				34);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_preloader_idle_time);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->spawn_method.data != NULL) {
+			pos = ngx_copy(pos,
+				"PASSENGER_SPAWN_METHOD",
+				23);
+			pos = ngx_copy(pos,
+				conf->spawn_method.data,
+				conf->spawn_method.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->union_station_key.data != NULL) {
+			pos = ngx_copy(pos,
+				"UNION_STATION_KEY",
+				18);
+			pos = ngx_copy(pos,
+				conf->union_station_key.data,
+				conf->union_station_key.len);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->max_request_queue_size != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_MAX_REQUEST_QUEUE_SIZE",
+				33);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->max_request_queue_size);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+	
+		if (conf->request_queue_overflow_status_code != NGX_CONF_UNSET) {
+			pos = ngx_copy(pos,
+				"PASSENGER_REQUEST_QUEUE_OVERFLOW_STATUS_CODE",
+				45);
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%d",
+				conf->request_queue_overflow_status_code);
+			pos = ngx_copy(pos,
+				int_buf,
+				end - int_buf);
+			*pos = '\0';
+			pos++;
+		}
+	
+
+
+conf->options_cache.data = buf;
+conf->options_cache.len = pos - buf;