passenger 4.0.60 → 5.0.0.beta1

data/ext/nginx/Configuration.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) Igor Sysoev
  * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
- * Copyright (C) 2010-2013 Phusion
+ * Copyright (C) 2010-2014 Phusion
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -34,10 +34,13 @@
 typedef struct {
     ngx_http_upstream_conf_t upstream_config;
     ngx_array_t *flushes;
-    ngx_array_t *vars_len;
-    ngx_array_t *vars;
-    /** Raw SCGI header data for this location is cached here. */
+    ngx_array_t *headers_set_len;
+    ngx_array_t *headers_set;
+    ngx_hash_t   headers_set_hash;
+
+    /** Raw HTTP header data for this location are cached here. */
     ngx_str_t    options_cache;
+    ngx_str_t    env_vars_cache;
 
     #include "ConfigurationFields.h"
 
@@ -54,10 +57,14 @@ typedef struct {
     ngx_str_t    default_ruby;
     ngx_int_t    log_level;
     ngx_str_t    debug_log_file;
-    ngx_str_t    temp_dir;
+    ngx_str_t    data_buffer_dir;
+    ngx_str_t    instance_registry_dir;
     ngx_flag_t   abort_on_startup_error;
     ngx_uint_t   max_pool_size;
     ngx_uint_t   pool_idle_time;
+    ngx_uint_t   stat_throttle_rate;
+    ngx_flag_t   turbocaching;
+    ngx_flag_t   show_version_in_header;
     ngx_flag_t   user_switching;
     ngx_str_t    default_user;
     ngx_str_t    default_group;

data/ext/nginx/ConfigurationCommands.c

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -239,16 +239,6 @@
 	NULL
 },
 
-{
-	
-	ngx_string("passenger_show_version_in_header"),
-	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_FLAG,
-	ngx_conf_set_flag_slot,
-	NGX_HTTP_LOC_CONF_OFFSET,
-	offsetof(passenger_loc_conf_t, show_version_in_header),
-	NULL
-},
-
 {
 	
 	ngx_string("passenger_max_preloader_idle_time"),
@@ -271,11 +261,21 @@
 
 {
 	
-	ngx_string("passenger_set_cgi_param"),
-	NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE2,
-	set_null_terminated_keyval_slot,
+	ngx_string("passenger_env_var"),
+	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE2,
+	ngx_conf_set_keyval_slot,
+	NGX_HTTP_LOC_CONF_OFFSET,
+	offsetof(passenger_loc_conf_t, env_vars),
+	NULL
+},
+
+{
+	
+	ngx_string("passenger_set_header"),
+	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE2,
+	ngx_conf_set_keyval_slot,
 	NGX_HTTP_LOC_CONF_OFFSET,
-	offsetof(passenger_loc_conf_t, vars_source),
+	offsetof(passenger_loc_conf_t, headers_source),
 	NULL
 },
 
@@ -289,6 +289,26 @@
 	NULL
 },
 
+{
+	
+	ngx_string("passenger_headers_hash_max_size"),
+	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE1,
+	ngx_conf_set_num_slot,
+	NGX_HTTP_LOC_CONF_OFFSET,
+	offsetof(passenger_loc_conf_t, headers_hash_max_size),
+	NULL
+},
+
+{
+	
+	ngx_string("passenger_headers_hash_bucket_size"),
+	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE1,
+	ngx_conf_set_num_slot,
+	NGX_HTTP_LOC_CONF_OFFSET,
+	offsetof(passenger_loc_conf_t, headers_hash_bucket_size),
+	NULL
+},
+
 {
 	
 	ngx_string("passenger_ignore_client_abort"),

data/ext/nginx/ConfigurationCommands.c.erb

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -64,7 +64,7 @@ def take_type_for(option)
 	return option[:take] if option[:take]
 
 	case option[:type]
-	when :string, :integer, :string_array
+	when :string, :integer, :uinteger, :string_array
 		return "NGX_CONF_TAKE1"
 	when :flag
 		return "NGX_CONF_FLAG"
@@ -81,14 +81,14 @@ def setter_function_for(option)
 	case option[:type]
 	when :string
 		return "ngx_conf_set_str_slot"
-	when :integer
+	when :integer, :uinteger
 		return "ngx_conf_set_num_slot"
 	when :flag
 		return "ngx_conf_set_flag_slot"
 	when :string_array
 		return "ngx_conf_set_str_array_slot"
 	when :string_keyval
-		return "set_null_terminated_keyval_slot"
+		return "ngx_conf_set_keyval_slot"
 	when :path
 		return "ngx_conf_set_path_slot"
 	else

data/ext/nginx/ConfigurationFields.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -45,8 +45,16 @@
 
 	ngx_int_t enabled;
 
+	ngx_array_t *env_vars;
+
 	ngx_int_t friendly_error_pages;
 
+	ngx_uint_t headers_hash_bucket_size;
+
+	ngx_uint_t headers_hash_max_size;
+
+	ngx_array_t *headers_source;
+
 	ngx_int_t load_shell_envvars;
 
 	ngx_int_t max_instances_per_app;
@@ -61,8 +69,6 @@
 
 	ngx_int_t request_queue_overflow_status_code;
 
-	ngx_int_t show_version_in_header;
-
 	ngx_int_t start_timeout;
 
 	ngx_int_t sticky_sessions;
@@ -71,8 +77,6 @@
 
 	ngx_int_t union_station_support;
 
-	ngx_array_t *vars_source;
-
 	ngx_str_t app_group_name;
 
 	ngx_str_t app_rights;

data/ext/nginx/ConfigurationFields.h.erb

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -63,6 +63,8 @@ def definition_for(option)
 		return ["ngx_str_t #{field}", 8 + 4, field]
 	when :integer, :flag
 		return ["ngx_int_t #{field}", 8, field]
+	when :uinteger
+		return ["ngx_uint_t #{field}", 8, field]
 	when :string_array, :string_keyval
 		return ["ngx_array_t *#{field}", 8, field];
 	else

data/ext/nginx/ContentHandler.c

@@ -53,13 +53,6 @@ static void abort_request(ngx_http_request_t *r);
 static void finalize_request(ngx_http_request_t *r, ngx_int_t rc);
 
 
-static unsigned int
-uint_to_str(ngx_uint_t i, u_char *str, ngx_uint_t size) {
-    unsigned int len = ngx_snprintf(str, size - 1, "%ui", i) - str;
-    str[len] = '\0';
-    return len;
-}
-
 static FileType
 get_file_type(const u_char *filename, unsigned int throttle_rate) {
     struct stat buf;
@@ -204,8 +197,8 @@ static void
 set_upstream_server_address(ngx_http_upstream_t *upstream, ngx_http_upstream_conf_t *upstream_config) {
     ngx_http_upstream_server_t *servers = upstream_config->upstream->servers->elts;
     ngx_addr_t                 *address = &servers[0].addrs[0];
-    const char                 *request_socket_filename;
-    unsigned int                request_socket_filename_len;
+    const char                 *server_address;
+    unsigned int                server_address_len;
     struct sockaddr_un         *sockaddr;
 
     /* The Nginx API makes it extremely difficult to register an upstream server
@@ -218,13 +211,15 @@ set_upstream_server_address(ngx_http_upstream_t *upstream, ngx_http_upstream_con
      */
     if (address->name.data == pp_placeholder_upstream_address.data) {
         sockaddr = (struct sockaddr_un *) address->sockaddr;
-        request_socket_filename =
-            pp_agents_starter_get_request_socket_filename(pp_agents_starter,
-                                                           &request_socket_filename_len);
-
-        address->name.data = (u_char *) request_socket_filename;
-        address->name.len  = request_socket_filename_len;
-        strncpy(sockaddr->sun_path, request_socket_filename, sizeof(sockaddr->sun_path));
+        server_address =
+            pp_agents_starter_get_server_address(pp_agents_starter,
+                                                 &server_address_len);
+        server_address += sizeof("unix:") - 1;
+        server_address_len -= sizeof("unix:") - 1;
+
+        address->name.data = (u_char *) server_address;
+        address->name.len  = server_address_len;
+        strncpy(sockaddr->sun_path, server_address, sizeof(sockaddr->sun_path));
         sockaddr->sun_path[sizeof(sockaddr->sun_path) - 1] = '\0';
     }
 }
@@ -242,8 +237,8 @@ fix_peer_address(ngx_http_request_t *r) {
     ngx_http_upstream_rr_peers_t     *peers;
     ngx_http_upstream_rr_peer_t      *peer;
     unsigned int                      peer_index;
-    const char                       *request_socket_filename;
-    unsigned int                      request_socket_filename_len;
+    const char                       *server_address;
+    unsigned int                      server_address_len;
 
     if (r->upstream->peer.get != ngx_http_upstream_get_round_robin_peer) {
         /* This function only supports the round-robin upstream method. */
@@ -252,24 +247,24 @@ fix_peer_address(ngx_http_request_t *r) {
 
     rrp        = r->upstream->peer.data;
     peers      = rrp->peers;
-    request_socket_filename =
-        pp_agents_starter_get_request_socket_filename(pp_agents_starter,
-                                                       &request_socket_filename_len);
+    server_address =
+        pp_agents_starter_get_server_address(pp_agents_starter,
+                                             &server_address_len);
 
     while (peers != NULL) {
         if (peers->name) {
-            if (peers->name->data == (u_char *) request_socket_filename) {
+            if (peers->name->data == (u_char *) server_address) {
                 /* Peer names already fixed. */
                 return;
             }
-            peers->name->data = (u_char *) request_socket_filename;
-            peers->name->len  = request_socket_filename_len;
+            peers->name->data = (u_char *) server_address;
+            peers->name->len  = server_address_len;
         }
         peer_index = 0;
         while (1) {
             peer = &peers->peer[peer_index];
-            peer->name.data = (u_char *) request_socket_filename;
-            peer->name.len  = request_socket_filename_len;
+            peer->name.data = (u_char *) server_address;
+            peer->name.len  = server_address_len;
             if (peer->down) {
                 peer_index++;
             } else {
@@ -320,436 +315,474 @@ header_is_transfer_encoding(ngx_str_t *key)
         ngx_strncasecmp(key->data + 1, (u_char *) "ransfer-encodin", sizeof("ransfer-encodin") - 1) == 0;
 }
 
-static int
-header_contains_non_alphanumdash(ngx_str_t *key)
-{
-	unsigned int i;
-	for (i = 0; i < key->len; i++) {
-		u_char c = key->data[i];
-		if (!(c >= 'a' && c <= 'z') && !(c >= 'A' && c <= 'Z') && !(c == '-') && !(c >= '0' && c <= '9')) {
-			return 1;
-		}
-	}
-	return 0;
-}
+#define SET_NGX_STR(str, the_data) \
+    do { \
+        (str)->data = (u_char *) the_data; \
+        (str)->len  = sizeof(the_data) - 1; \
+    } while (0)
+
+#define SET_NGX_STR_WITH_NULL(str, the_data) \
+    do { \
+        (str)->data = (u_char *) the_data; \
+        (str)->len  = sizeof(the_data); \
+    } while (0)
+
+typedef struct {
+    ngx_str_t     method; /* Includes trailing space */
+    ngx_str_t     app_type;
+    ngx_str_t     escaped_uri;
+    ngx_str_t     content_length;
+    ngx_str_t     server_password;
+    ngx_str_t     remote_port;
+} buffer_construction_state;
 
 static ngx_int_t
-create_request(ngx_http_request_t *r)
+prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *context,
+    buffer_construction_state *state)
 {
-    u_char                         ch;
-    const char *                   helper_agent_request_socket_password_data;
-    unsigned int                   helper_agent_request_socket_password_len;
-    u_char                         buf[sizeof("4294967296") + 1];
-    size_t                         len, size, key_len, val_len;
-    const u_char                  *app_type_string;
-    size_t                         app_type_string_len;
-    int                            server_name_len;
-    ngx_str_t                      escaped_uri;
-    ngx_str_t                     *union_station_filters = NULL;
-    void                          *tmp;
-    ngx_uint_t                     i, n;
-    ngx_buf_t                     *b;
-    ngx_chain_t                   *cl, *body;
-    ngx_list_part_t               *part;
-    ngx_table_elt_t               *header;
-    ngx_http_script_code_pt        code;
-    ngx_http_script_engine_t       e, le;
-    ngx_http_core_srv_conf_t      *cscf;
-    passenger_loc_conf_t          *slcf;
-    passenger_context_t           *context;
-    ngx_http_script_len_code_pt    lcode;
+    unsigned int          len;
+    ngx_uint_t            port;
+    struct sockaddr_in   *sin;
+#if (NGX_HAVE_INET6)
+    struct sockaddr_in6  *sin6;
+#endif
 
-    cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
-    slcf = ngx_http_get_module_loc_conf(r, ngx_http_passenger_module);
-    context = ngx_http_get_module_ctx(r, ngx_http_passenger_module);
-    if (context == NULL) {
-        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    switch (r->method) {
+    case NGX_HTTP_GET:
+        SET_NGX_STR(&state->method, "GET ");
+        break;
+    case NGX_HTTP_HEAD:
+        SET_NGX_STR(&state->method, "HEAD ");
+        break;
+    case NGX_HTTP_POST:
+        SET_NGX_STR(&state->method, "POST ");
+        break;
+    case NGX_HTTP_PUT:
+        SET_NGX_STR(&state->method, "PUT ");
+        break;
+    case NGX_HTTP_DELETE:
+        SET_NGX_STR(&state->method, "DELETE ");
+        break;
+    case NGX_HTTP_MKCOL:
+        SET_NGX_STR(&state->method, "MKCOL ");
+        break;
+    case NGX_HTTP_COPY:
+        SET_NGX_STR(&state->method, "COPY ");
+        break;
+    case NGX_HTTP_MOVE:
+        SET_NGX_STR(&state->method, "MOVE ");
+        break;
+    case NGX_HTTP_OPTIONS:
+        SET_NGX_STR(&state->method, "OPTIONS ");
+        break;
+    case NGX_HTTP_PROPFIND:
+        SET_NGX_STR(&state->method, "PROPFIND ");
+        break;
+    case NGX_HTTP_PROPPATCH:
+        SET_NGX_STR(&state->method, "PROPPATCH ");
+        break;
+    case NGX_HTTP_LOCK:
+        SET_NGX_STR(&state->method, "LOCK ");
+        break;
+    case NGX_HTTP_UNLOCK:
+        SET_NGX_STR(&state->method, "UNLOCK ");
+        break;
+    case NGX_HTTP_PATCH:
+        SET_NGX_STR(&state->method, "PATCH ");
+        break;
+    case NGX_HTTP_TRACE:
+        SET_NGX_STR(&state->method, "TRACE ");
+        break;
+    default:
+        SET_NGX_STR(&state->method, "UNKNOWN ");
+        break;
     }
 
-    app_type_string = (const u_char *) pp_get_app_type_name(context->app_type);
-    app_type_string_len = strlen((const char *) app_type_string) + 1; /* include null terminator */
-
+    state->app_type.data = (u_char *) pp_get_app_type_name(context->app_type);
+    /* Include null terminator */
+    state->app_type.len  = strlen((const char *) state->app_type.data) + 1;
 
     /*
      * Nginx unescapes URI's before passing them to Phusion Passenger,
      * but backend processes expect the escaped version.
      * http://code.google.com/p/phusion-passenger/issues/detail?id=404
      */
-    escaped_uri.len =
+    state->escaped_uri.len =
         2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len, NGX_ESCAPE_URI)
         + r->uri.len;
-    escaped_uri.data = ngx_pnalloc(r->pool, escaped_uri.len + 1);
-    escaped_uri.data[escaped_uri.len] = '\0';
-    ngx_escape_uri(escaped_uri.data, r->uri.data, r->uri.len, NGX_ESCAPE_URI);
+    state->escaped_uri.data = ngx_pnalloc(r->pool, state->escaped_uri.len);
+    if (state->escaped_uri.data == NULL) {
+        return NGX_ERROR;
+    }
+    ngx_escape_uri(state->escaped_uri.data, r->uri.data, r->uri.len,
+        NGX_ESCAPE_URI);
+
+    if (r->headers_in.chunked) {
+        /* If the request body is chunked, then Nginx sets r->headers_in.content_length_n
+         * but does not set r->headers_in.headers, so we add this header ourselves.
+         */
+        state->content_length.data = ngx_pnalloc(r->pool, sizeof("4294967295") - 1);
+        state->content_length.len = ngx_snprintf(state->content_length.data,
+            sizeof("4294967295") - 1, "%O", r->headers_in.content_length_n)
+            - state->content_length.data;
+    }
 
+    state->server_password.data = (u_char *) pp_agents_starter_get_server_password(
+        pp_agents_starter, &len);
+    state->server_password.len  = len;
 
-    /**************************************************
-     * Determine the request header length.
-     **************************************************/
+    switch (r->connection->sockaddr->sa_family) {
+    #if (NGX_HAVE_INET6)
+    case AF_INET6:
+        sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;
+        port = ntohs(sin6->sin6_port);
+        break;
+    #endif
 
-    len = 0;
+    #if (NGX_HAVE_UNIX_DOMAIN)
+    case AF_UNIX:
+        port = 0;
+        break;
+    #endif
 
-    /* Length of the Content-Length header. A value of -1 means that the content
-     * length is unspecified, which is the case for e.g. WebSocket requests. */
-    if (r->headers_in.content_length_n >= 0) {
-        len += sizeof("CONTENT_LENGTH") +
-            uint_to_str(r->headers_in.content_length_n, buf, sizeof(buf)) +
-            1; /* +1 for trailing null */
+    default: /* AF_INET */
+        sin = (struct sockaddr_in *) r->connection->sockaddr;
+        port = ntohs(sin->sin_port);
+        break;
     }
 
-    /* DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */
-    len += sizeof("DOCUMENT_ROOT") + context->public_dir.len + 1;
-    if (context->base_uri.len > 0) {
-        len += sizeof("SCRIPT_NAME") + context->base_uri.len + 1;
-        len += sizeof("RAILS_RELATIVE_URL_ROOT") +
-               context->base_uri.len + 1;
-        len += sizeof("PATH_INFO") + escaped_uri.len - context->base_uri.len + 1;
-    } else {
-        len += sizeof("SCRIPT_NAME") + sizeof("");
-        len += sizeof("PATH_INFO") + escaped_uri.len + 1;
-    }
-    len += sizeof("REQUEST_URI") + escaped_uri.len + 1;
-    if (r->args.len > 0) {
-        len += 1 + r->args.len;
+    state->remote_port.data = ngx_pnalloc(r->pool, sizeof("65535") - 1);
+    if (state->remote_port.data == NULL) {
+        return NGX_ERROR;
     }
 
-    /* SERVER_NAME; must be equal to HTTP_HOST without the port part */
-    if (r->headers_in.host != NULL) {
-        tmp = memchr(r->headers_in.host->value.data, ':', r->headers_in.host->value.len);
-        if (tmp == NULL) {
-            server_name_len = r->headers_in.host->value.len;
-        } else {
-            server_name_len = (int) ((const u_char *) tmp - r->headers_in.host->value.data);
-        }
+    if (port > 0 && port < 65536) {
+        state->remote_port.len = ngx_snprintf(state->remote_port.data,
+            sizeof("65535") - 1, "%ui", port) - state->remote_port.data;
     } else {
-        server_name_len = cscf->server_name.len;
+        state->remote_port.len = 0;
     }
-    len += sizeof("SERVER_NAME") + server_name_len + 1;
 
-    /* Various other HTTP headers. */
-    if (r->headers_in.content_type != NULL
-     && r->headers_in.content_type->value.len > 0) {
-        len += sizeof("CONTENT_TYPE") + r->headers_in.content_type->value.len + 1;
+    return NGX_OK;
+}
+
+static ngx_uint_t
+construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
+    passenger_context_t *context, buffer_construction_state *state, ngx_buf_t *b)
+{
+    #define PUSH_STATIC_STR(str) \
+        do { \
+            if (b != NULL) { \
+                b->last = ngx_copy(b->last, (const u_char *) str, \
+                    sizeof(str) - 1); \
+            } \
+            total_size += sizeof(str) - 1; \
+        } while (0)
+
+    ngx_uint_t       total_size = 0;
+    ngx_str_t       *union_station_filters;
+    ngx_uint_t       i;
+    ngx_list_part_t *part;
+    ngx_table_elt_t *header;
+    size_t           len;
+    ngx_http_script_len_code_pt lcode;
+    ngx_http_script_code_pt     code;
+    ngx_http_script_engine_t    e, le;
+
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, state->method.data, state->method.len);
     }
+    total_size += state->method.len;
 
-    #if (NGX_HTTP_SSL)
-        if (r->http_connection->ssl) {
-            len += sizeof("HTTPS") + sizeof("on");
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, state->escaped_uri.data, state->escaped_uri.len);
+    }
+    total_size += state->escaped_uri.len;
+    if (r->args.len > 0) {
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, "?", 1);
+            b->last = ngx_copy(b->last, r->args.data, r->args.len);
         }
-    #endif
+        total_size += r->args.len + 1;
+    }
 
-    /* Lengths of Passenger application pool options. */
-    len += slcf->options_cache.len;
+    PUSH_STATIC_STR(" HTTP/1.1\r\nConnection: close\r\n");
 
-    len += sizeof("PASSENGER_APP_TYPE") + app_type_string_len;
+    part = &r->headers_in.headers.part;
+    header = part->elts;
+    for (i = 0; /* void */; i++) {
+        if (i >= part->nelts) {
+            if (part->next == NULL) {
+                break;
+            }
 
-    if (slcf->union_station_filters != NGX_CONF_UNSET_PTR && slcf->union_station_filters->nelts > 0) {
-        len += sizeof("UNION_STATION_FILTERS");
+            part = part->next;
+            header = part->elts;
+            i = 0;
+        }
 
-        union_station_filters = (ngx_str_t *) slcf->union_station_filters->elts;
-        for (i = 0; i < slcf->union_station_filters->nelts; i++) {
-            if (i != 0) {
-                len++;
-            }
-            len += union_station_filters[i].len;
+        if (ngx_hash_find(&slcf->headers_set_hash, header[i].hash,
+                          header[i].lowcase_key, header[i].key.len)
+         || header_is_transfer_encoding(&header[i].key))
+        {
+            continue;
         }
-        len++;
-    }
 
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, header[i].key.data, header[i].key.len);
+            b->last = ngx_copy(b->last, ": ", 2);
+            b->last = ngx_copy(b->last, header[i].value.data, header[i].value.len);
+            b->last = ngx_copy(b->last, "\r\n", 2);
+        }
+        total_size += header[i].key.len + header[i].value.len + 4;
+    }
 
-    /***********************/
-    /***********************/
+    if (r->headers_in.chunked) {
+        PUSH_STATIC_STR("Content-Length: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, state->content_length.data,
+                state->content_length.len);
+        }
+        total_size += state->content_length.len;
+        PUSH_STATIC_STR("\r\n");
+    }
 
-    /* Lengths of various CGI variables. */
-    if (slcf->vars_len) {
+    if (slcf->headers_set_len) {
         ngx_memzero(&le, sizeof(ngx_http_script_engine_t));
 
         ngx_http_script_flush_no_cacheable_variables(r, slcf->flushes);
-        le.flushed = 1;
 
-        le.ip = slcf->vars_len->elts;
+        le.ip = slcf->headers_set_len->elts;
         le.request = r;
+        le.flushed = 1;
 
         while (*(uintptr_t *) le.ip) {
-
-            lcode = *(ngx_http_script_len_code_pt *) le.ip;
-            key_len = lcode(&le);
-
-            for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
+            while (*(uintptr_t *) le.ip) {
                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
+                total_size += lcode(&le);
             }
             le.ip += sizeof(uintptr_t);
-
-            len += key_len + val_len;
         }
-    }
-
-    /* Lengths of HTTP headers. */
-    if (slcf->upstream_config.pass_request_headers) {
 
-        part = &r->headers_in.headers.part;
-        header = part->elts;
+        if (b != NULL) {
+            ngx_memzero(&e, sizeof(ngx_http_script_engine_t));
 
-        for (i = 0; /* void */; i++) {
+            e.ip = slcf->headers_set->elts;
+            e.pos = b->last;
+            e.request = r;
+            e.flushed = 1;
 
-            if (i >= part->nelts) {
-                if (part->next == NULL) {
-                    break;
-                }
-
-                part = part->next;
-                header = part->elts;
-                i = 0;
-            }
-
-            if (!header_is_transfer_encoding(&header[i].key) && !header_contains_non_alphanumdash(&header[i].key)) {
-                len += sizeof("HTTP_") - 1 + header[i].key.len + 1
-                    + header[i].value.len + 1;
-            }
-        }
-    }
+            le.ip = slcf->headers_set_len->elts;
 
+            while (*(uintptr_t *) le.ip) {
+                lcode = *(ngx_http_script_len_code_pt *) le.ip;
 
-    /**************************************************
-     * Build the request header data.
-     **************************************************/
+                /* skip the header line name length */
+                (void) lcode(&le);
 
-    helper_agent_request_socket_password_data =
-        pp_agents_starter_get_request_socket_password(pp_agents_starter,
-            &helper_agent_request_socket_password_len);
-    size = helper_agent_request_socket_password_len +
-        /* netstring length + ":" + trailing "," */
-        /* note: 10 == sizeof("4294967296") - 1 */
-        len + 10 + 1 + 1;
+                if (*(ngx_http_script_len_code_pt *) le.ip) {
 
-    b = ngx_create_temp_buf(r->pool, size);
-    if (b == NULL) {
-        return NGX_ERROR;
-    }
+                    for (len = 0; *(uintptr_t *) le.ip; len += lcode(&le)) {
+                        lcode = *(ngx_http_script_len_code_pt *) le.ip;
+                    }
 
-    cl = ngx_alloc_chain_link(r->pool);
-    if (cl == NULL) {
-        return NGX_ERROR;
-    }
+                    e.skip = (len == sizeof("\r\n") - 1) ? 1 : 0;
 
-    cl->buf = b;
+                } else {
+                    e.skip = 0;
+                }
 
-    /* Build SCGI header netstring length part. */
-    b->last = ngx_copy(b->last, helper_agent_request_socket_password_data,
-                       helper_agent_request_socket_password_len);
+                le.ip += sizeof(uintptr_t);
 
-    b->last = ngx_snprintf(b->last, 10, "%ui", len);
-    *b->last++ = (u_char) ':';
+                while (*(uintptr_t *) e.ip) {
+                    code = *(ngx_http_script_code_pt *) e.ip;
+                    code((ngx_http_script_engine_t *) &e);
+                }
+                e.ip += sizeof(uintptr_t);
+            }
 
-    if (r->headers_in.content_length_n >= 0) {
-        b->last = ngx_copy(b->last, "CONTENT_LENGTH",
-                           sizeof("CONTENT_LENGTH"));
+            b->last = e.pos;
+        }
+    }
 
-        b->last = ngx_snprintf(b->last, 10, "%O",
-            r->headers_in.content_length_n);
-        *b->last++ = (u_char) 0;
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, "!~: ", sizeof("!~: ") - 1);
+        b->last = ngx_copy(b->last, state->server_password.data,
+            state->server_password.len);
+        b->last = ngx_copy(b->last, "\r\n", sizeof("\r\n") - 1);
     }
+    total_size += (sizeof("!~: \r\n") - 1) + state->server_password.len;
 
-    /* Build DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */
-    b->last = ngx_copy(b->last, "DOCUMENT_ROOT", sizeof("DOCUMENT_ROOT"));
-    b->last = ngx_copy(b->last, context->public_dir.data,
-                       context->public_dir.len + 1);
+    PUSH_STATIC_STR("!~DOCUMENT_ROOT: ");
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, context->public_dir.data,
+            context->public_dir.len);
+    }
+    total_size += context->public_dir.len;
+    PUSH_STATIC_STR("\r\n");
 
     if (context->base_uri.len > 0) {
-        b->last = ngx_copy(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME"));
-        b->last = ngx_copy(b->last, context->base_uri.data,
-                           context->base_uri.len + 1);
-
-        b->last = ngx_copy(b->last, "RAILS_RELATIVE_URL_ROOT",
-                           sizeof("RAILS_RELATIVE_URL_ROOT"));
-        b->last = ngx_copy(b->last, context->base_uri.data,
-                           context->base_uri.len + 1);
-
-        b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO"));
-        b->last = ngx_copy(b->last, escaped_uri.data + context->base_uri.len,
-                           escaped_uri.len - context->base_uri.len);
-        b->last = ngx_copy(b->last, "", 1);
-    } else {
-        b->last = ngx_copy(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME"));
-        b->last = ngx_copy(b->last, "", sizeof(""));
-
-        b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO"));
-        b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len);
-        b->last = ngx_copy(b->last, "", 1);
+        PUSH_STATIC_STR("!~SCRIPT_NAME: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, context->base_uri.data,
+                context->base_uri.len);
+        }
+        total_size += context->base_uri.len;
+        PUSH_STATIC_STR("\r\n");
     }
 
-    b->last = ngx_copy(b->last, "REQUEST_URI", sizeof("REQUEST_URI"));
-    b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len);
-    if (r->args.len > 0) {
-        b->last = ngx_copy(b->last, "?", 1);
-        b->last = ngx_copy(b->last, r->args.data, r->args.len);
+    PUSH_STATIC_STR("!~REMOTE_ADDR: ");
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, r->connection->addr_text.data,
+            r->connection->addr_text.len);
     }
-    b->last = ngx_copy(b->last, "", 1);
+    total_size += r->connection->addr_text.len;
+    PUSH_STATIC_STR("\r\n");
 
-    /* SERVER_NAME */
-    b->last = ngx_copy(b->last, "SERVER_NAME", sizeof("SERVER_NAME"));
-    if (r->headers_in.host != NULL) {
-        b->last = ngx_copy(b->last, r->headers_in.host->value.data,
-                           server_name_len);
-    } else {
-        b->last = ngx_copy(b->last, cscf->server_name.data,
-                           server_name_len);
+    PUSH_STATIC_STR("!~REMOTE_PORT: ");
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, state->remote_port.data,
+            state->remote_port.len);
     }
-    b->last = ngx_copy(b->last, "", 1);
-
-    /* Various other HTTP headers. */
-    if (r->headers_in.content_type != NULL
-     && r->headers_in.content_type->value.len > 0) {
-        b->last = ngx_copy(b->last, "CONTENT_TYPE", sizeof("CONTENT_TYPE"));
-        b->last = ngx_copy(b->last, r->headers_in.content_type->value.data,
-                           r->headers_in.content_type->value.len);
-        b->last = ngx_copy(b->last, "", 1);
+    total_size += state->remote_port.len;
+    PUSH_STATIC_STR("\r\n");
+
+    if (r->headers_in.user.len > 0) {
+        PUSH_STATIC_STR("!~REMOTE_USER: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, r->headers_in.user.data,
+                r->headers_in.user.len);
+        }
+        total_size += r->headers_in.user.len;
+        PUSH_STATIC_STR("\r\n");
     }
 
-    #if (NGX_HTTP_SSL)
-        if (r->http_connection->ssl) {
-            b->last = ngx_copy(b->last, "HTTPS", sizeof("HTTPS"));
-            b->last = ngx_copy(b->last, "on", sizeof("on"));
+    if (slcf->app_group_name.data == NULL) {
+        PUSH_STATIC_STR("!~PASSENGER_APP_GROUP_NAME: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, context->public_dir.data,
+                context->public_dir.len);
         }
-    #endif
-
-
-    /* Build Passenger application pool option headers. */
-    b->last = ngx_copy(b->last, slcf->options_cache.data, slcf->options_cache.len);
-
-    b->last = ngx_copy(b->last, "PASSENGER_APP_TYPE",
-                       sizeof("PASSENGER_APP_TYPE"));
-    b->last = ngx_copy(b->last, app_type_string, app_type_string_len);
-
-    if (slcf->union_station_filters != NGX_CONF_UNSET_PTR && slcf->union_station_filters->nelts > 0) {
-        b->last = ngx_copy(b->last, "UNION_STATION_FILTERS",
-                           sizeof("UNION_STATION_FILTERS"));
-
-        for (i = 0; i < slcf->union_station_filters->nelts; i++) {
-            if (i != 0) {
-                b->last = ngx_copy(b->last, "\1", 1);
+        total_size += context->public_dir.len;
+        if (slcf->environment.data != NULL) {
+            if (b != NULL) {
+                b->last = ngx_copy(b->last, " (", 2);
+                b->last = ngx_copy(b->last, slcf->environment.data,
+                    slcf->environment.len);
+                b->last = ngx_copy(b->last, ")", 1);
             }
-            b->last = ngx_copy(b->last, union_station_filters[i].data,
-                               union_station_filters[i].len);
+            total_size += (sizeof(" (") - 1) + slcf->environment.len + (sizeof(")") - 1);
         }
-        b->last = ngx_copy(b->last, "\0", 1);
+        PUSH_STATIC_STR("\r\n");
     }
 
-    /***********************/
-    /***********************/
-
-    if (slcf->vars_len) {
-        ngx_memzero(&e, sizeof(ngx_http_script_engine_t));
-
-        e.ip = slcf->vars->elts;
-        e.pos = b->last;
-        e.request = r;
-        e.flushed = 1;
-
-        le.ip = slcf->vars_len->elts;
-
-        while (*(uintptr_t *) le.ip) {
-
-            lcode = *(ngx_http_script_len_code_pt *) le.ip;
-            (void) lcode(&le);
-
-            for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
-                lcode = *(ngx_http_script_len_code_pt *) le.ip;
-            }
-            le.ip += sizeof(uintptr_t);
-
-            while (*(uintptr_t *) e.ip) {
-                code = *(ngx_http_script_code_pt *) e.ip;
-                code((ngx_http_script_engine_t *) &e);
+    if (slcf->union_station_filters != NGX_CONF_UNSET_PTR
+     && slcf->union_station_filters->nelts > 0)
+    {
+        union_station_filters = (ngx_str_t *) slcf->union_station_filters->elts;
+        for (i = 0; i < slcf->union_station_filters->nelts; i++) {
+            PUSH_STATIC_STR("!~UNION_STATION_FILTERS: ");
+            if (b != NULL) {
+                b->last = ngx_copy(b->last, union_station_filters[i].data,
+                    union_station_filters[i].len);
             }
-            e.ip += sizeof(uintptr_t);
+            total_size += union_station_filters[i].len;
+            PUSH_STATIC_STR("\r\n");
         }
-
-        b->last = e.pos;
     }
 
+    if (b != NULL) {
+        b->last = ngx_copy(b->last, slcf->options_cache.data, slcf->options_cache.len);
+    }
+    total_size += slcf->options_cache.len;
 
-    if (slcf->upstream_config.pass_request_headers) {
-
-        part = &r->headers_in.headers.part;
-        header = part->elts;
-
-        for (i = 0; /* void */; i++) {
-
-            if (i >= part->nelts) {
-                if (part->next == NULL) {
-                    break;
-                }
-
-                part = part->next;
-                header = part->elts;
-                i = 0;
-            }
-
-            if (header_contains_non_alphanumdash(&header[i].key)) {
-            	continue;
-            }
+    if (slcf->env_vars_cache.data != NULL) {
+        PUSH_STATIC_STR("!~PASSENGER_ENV_VARS: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, slcf->env_vars_cache.data, slcf->env_vars_cache.len);
+        }
+        total_size += slcf->env_vars_cache.len;
+        PUSH_STATIC_STR("\r\n");
+    }
 
-            if (header_is_transfer_encoding(&header[i].key)) {
-                continue;
-            }
+    /* D = Dechunk response
+     *     Prevent Nginx from rechunking the response.
+     * C = Strip 100 Continue header
+     * S = SSL
+     */
 
-            b->last = ngx_cpymem(b->last, "HTTP_", sizeof("HTTP_") - 1);
+    PUSH_STATIC_STR("!~FLAGS: DC");
+    #if (NGX_HTTP_SSL)
+        if (r->http_connection->ssl) {
+            PUSH_STATIC_STR("S");
+        }
+    #endif
+    PUSH_STATIC_STR("\r\n\r\n");
 
-            for (n = 0; n < header[i].key.len; n++) {
-                ch = header[i].key.data[n];
+    return total_size;
 
-                if (ch >= 'a' && ch <= 'z') {
-                    ch &= ~0x20;
+    #undef PUSH_STATIC_STR
+}
 
-                } else if (ch == '-') {
-                    ch = '_';
-                }
+static ngx_int_t
+create_request(ngx_http_request_t *r)
+{
+    passenger_loc_conf_t          *slcf;
+    passenger_context_t           *context;
+    buffer_construction_state      state;
+    ngx_uint_t                     request_size;
+    ngx_buf_t                     *b;
+    ngx_chain_t                   *cl, *body;
 
-                *b->last++ = ch;
-            }
+    slcf = ngx_http_get_module_loc_conf(r, ngx_http_passenger_module);
+    context = ngx_http_get_module_ctx(r, ngx_http_passenger_module);
+    if (context == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
 
-            *b->last++ = (u_char) 0;
+    /* Construct and pass request headers */
 
-            b->last = ngx_copy(b->last, header[i].value.data,
-                               header[i].value.len);
-            *b->last++ = (u_char) 0;
-         }
+    if (prepare_request_buffer_construction(r, context, &state) != NGX_OK) {
+        return NGX_ERROR;
     }
+    request_size = construct_request_buffer(r, slcf, context, &state, NULL);
 
-    *b->last++ = (u_char) ',';
-
-    if (slcf->upstream_config.pass_request_body) {
+    b = ngx_create_temp_buf(r->pool, request_size);
+    if (b == NULL) {
+        return NGX_ERROR;
+    }
+    cl = ngx_alloc_chain_link(r->pool);
+    if (cl == NULL) {
+        return NGX_ERROR;
+    }
+    cl->buf = b;
 
-        body = r->upstream->request_bufs;
-        r->upstream->request_bufs = cl;
+    construct_request_buffer(r, slcf, context, &state, b);
 
-        while (body) {
-            b = ngx_alloc_buf(r->pool);
-            if (b == NULL) {
-                return NGX_ERROR;
-            }
+    /* Pass request body */
 
-            ngx_memcpy(b, body->buf, sizeof(ngx_buf_t));
+    body = r->upstream->request_bufs;
+    r->upstream->request_bufs = cl;
 
-            cl->next = ngx_alloc_chain_link(r->pool);
-            if (cl->next == NULL) {
-                return NGX_ERROR;
-            }
+    while (body) {
+        b = ngx_alloc_buf(r->pool);
+        if (b == NULL) {
+            return NGX_ERROR;
+        }
 
-            cl = cl->next;
-            cl->buf = b;
+        ngx_memcpy(b, body->buf, sizeof(ngx_buf_t));
 
-            body = body->next;
+        cl->next = ngx_alloc_chain_link(r->pool);
+        if (cl->next == NULL) {
+            return NGX_ERROR;
         }
 
-        b->flush = 1;
+        cl = cl->next;
+        cl->buf = b;
 
-    } else {
-        r->upstream->request_bufs = cl;
+        body = body->next;
     }
-
-
+    b->flush = 1;
     cl->next = NULL;
 
     return NGX_OK;
@@ -1056,11 +1089,9 @@ process_header(ngx_http_request_t *r)
     ngx_http_upstream_header_t     *hh;
     ngx_http_upstream_main_conf_t  *umcf;
     ngx_http_core_loc_conf_t       *clcf;
-    passenger_loc_conf_t           *slcf;
 
     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
-    slcf = ngx_http_get_module_loc_conf(r, ngx_http_passenger_module);
 
     for ( ;; ) {
 
@@ -1138,17 +1169,17 @@ process_header(ngx_http_request_t *r)
 
                 h->key.len = sizeof("Server") - 1;
                 h->key.data = (u_char *) "Server";
-                if( slcf->show_version_in_header == 0 ) {
+                if (!passenger_main_conf.show_version_in_header) {
                     if (clcf->server_tokens) {
-                        h->value.data = (u_char *) (NGINX_VER " + Phusion Passenger");
+                        h->value.data = (u_char *) (NGINX_VER " + " PROGRAM_NAME);
                     } else {
-                        h->value.data = (u_char *) ("nginx + Phusion Passenger");
+                        h->value.data = (u_char *) ("nginx + " PROGRAM_NAME);
                     }
                 } else {
                     if (clcf->server_tokens) {
-                        h->value.data = (u_char *) (NGINX_VER " + Phusion Passenger " PASSENGER_VERSION);
+                        h->value.data = (u_char *) (NGINX_VER " + " PROGRAM_NAME " " PASSENGER_VERSION);
                     } else {
-                        h->value.data = (u_char *) ("nginx + Phusion Passenger " PASSENGER_VERSION);
+                        h->value.data = (u_char *) ("nginx + " PROGRAM_NAME " " PASSENGER_VERSION);
                     }
                 }
                 h->value.len = ngx_strlen(h->value.data);