passenger 4.0.60 → 5.0.0.beta1

data/ext/nginx/CacheLocationConfig.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.
  *
@@ -68,8 +68,9 @@ u_char int_buf[32], *end, *buf, *pos;
 <% for option in filter_eligible_options(LOCATION_CONFIGURATION_OPTIONS) %>
 	<% if option[:type] == :string %>
 		if (conf-><%= struct_field_for(option) %>.data != NULL) {
-			len += <%= header_name_for(option).size + 1 %>;
-			len += conf-><%= struct_field_for(option) %>.len + 1;
+			len += sizeof("!~<%= header_name_for(option) %>: ") - 1;
+			len += conf-><%= struct_field_for(option) %>.len;
+			len += sizeof("\r\n") - 1;
 		}
 	<% elsif option[:type] == :integer %>
 		if (conf-><%= struct_field_for(option) %> != NGX_CONF_UNSET) {
@@ -77,13 +78,26 @@ u_char int_buf[32], *end, *buf, *pos;
 				sizeof(int_buf) - 1,
 				"%d",
 				conf-><%= struct_field_for(option) %>);
-			len += <%= header_name_for(option).size + 1 %>;
-			len += end - int_buf + 1;
+			len += sizeof("!~<%= header_name_for(option) %>: ") - 1;
+			len += end - int_buf;
+			len += sizeof("\r\n") - 1;
+		}
+	<% elsif option[:type] == :integer %>
+		if (conf-><%= struct_field_for(option) %> != NGX_CONF_UNSET_UINT) {
+			end = ngx_snprintf(int_buf,
+				sizeof(int_buf) - 1,
+				"%ui",
+				conf-><%= struct_field_for(option) %>);
+			len += sizeof("!~<%= header_name_for(option) %>: ") - 1;
+			len += end - int_buf;
+			len += sizeof("\r\n") - 1;
 		}
 	<% elsif option[:type] == :flag %>
 		if (conf-><%= struct_field_for(option) %> != NGX_CONF_UNSET) {
-			len += <%= header_name_for(option).size + 1 %>;
-			len += conf-><%= struct_field_for(option) %> ? sizeof("true") : sizeof("false");
+			len += sizeof("!~<%= header_name_for(option) %>: ") - 1;
+			len += conf-><%= struct_field_for(option) %>
+				? sizeof("t\r\n") - 1
+				: sizeof("f\r\n") - 1;
 		}
 	<% else %>
 		<% raise "Unknown option type #{option[:type].inspect} for option #{option[:name]}" %>
@@ -92,43 +106,42 @@ u_char int_buf[32], *end, *buf, *pos;
 
 /* Create string */
 buf = pos = ngx_pnalloc(cf->pool, len);
+if (buf == NULL) {
+	return NGX_ERROR;
+}
 
 <% for option in filter_eligible_options(LOCATION_CONFIGURATION_OPTIONS) %>
 	<% if option[:type] == :string %>
 		if (conf-><%= struct_field_for(option) %>.data != NULL) {
 			pos = ngx_copy(pos,
-				"<%= header_name_for(option) %>",
-				<%= header_name_for(option).size + 1 %>);
+				"!~<%= header_name_for(option) %>: ",
+				sizeof("!~<%= header_name_for(option) %>: ") - 1);
 			pos = ngx_copy(pos,
 				conf-><%= struct_field_for(option) %>.data,
 				conf-><%= struct_field_for(option) %>.len);
-			*pos = '\0';
-			pos++;
+			pos = ngx_copy(pos, (const u_char *) "\r\n", sizeof("\r\n") - 1);
 		}
 	<% elsif option[:type] == :integer %>
 		if (conf-><%= struct_field_for(option) %> != NGX_CONF_UNSET) {
 			pos = ngx_copy(pos,
-				"<%= header_name_for(option) %>",
-				<%= header_name_for(option).size + 1 %>);
+				"!~<%= header_name_for(option) %>: ",
+				sizeof("!~<%= header_name_for(option) %>: ") - 1);
 			end = ngx_snprintf(int_buf,
 				sizeof(int_buf) - 1,
 				"%d",
 				conf-><%= struct_field_for(option) %>);
-			pos = ngx_copy(pos,
-				int_buf,
-				end - int_buf);
-			*pos = '\0';
-			pos++;
+			pos = ngx_copy(pos, int_buf, end - int_buf);
+			pos = ngx_copy(pos, (const u_char *) "\r\n", sizeof("\r\n") - 1);
 		}
 	<% elsif option[:type] == :flag %>
 		if (conf-><%= struct_field_for(option) %> != NGX_CONF_UNSET) {
 			pos = ngx_copy(pos,
-				"<%= header_name_for(option) %>",
-				<%= header_name_for(option).size + 1 %>);
+				"!~<%= header_name_for(option) %>: ",
+				sizeof("!~<%= header_name_for(option) %>: ") - 1);
 			if (conf-><%= struct_field_for(option) %>) {
-				pos = ngx_copy(pos, "true", sizeof("true"));
+				pos = ngx_copy(pos, "t\r\n", sizeof("t\r\n") - 1);
 			} else {
-				pos = ngx_copy(pos, "false", sizeof("false"));
+				pos = ngx_copy(pos, "f\r\n", sizeof("f\r\n") - 1);
 			}
 		}
 	<% else %>

data/ext/nginx/Configuration.c

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) Igor Sysoev
  * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
- * Copyright (C) 2010-2015 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
@@ -31,12 +31,15 @@
 
 #include <sys/types.h>
 #include <pwd.h>
+#include <stdlib.h>
+#include <assert.h>
 
 #include "ngx_http_passenger_module.h"
 #include "Configuration.h"
 #include "ContentHandler.h"
 #include "common/Constants.h"
 #include "common/agents/LoggingAgent/FilterSupport.h"
+#include "common/Utils/modp_b64.h"
 
 
 static ngx_str_t headers_to_hide[] = {
@@ -56,6 +59,13 @@ static ngx_path_init_t  ngx_http_proxy_temp_path = {
     ngx_string(NGX_HTTP_PROXY_TEMP_PATH), { 1, 2, 0 }
 };
 
+static ngx_int_t merge_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf,
+    passenger_loc_conf_t *prev);
+static ngx_int_t merge_string_array(ngx_conf_t *cf, ngx_array_t **prev,
+    ngx_array_t **conf);
+static ngx_int_t merge_string_keyval_table(ngx_conf_t *cf, ngx_array_t **prev,
+    ngx_array_t **conf);
+
 
 void *
 passenger_create_main_conf(ngx_conf_t *cf)
@@ -76,10 +86,17 @@ passenger_create_main_conf(ngx_conf_t *cf)
     conf->log_level = (ngx_int_t) NGX_CONF_UNSET;
     conf->debug_log_file.data = NULL;
     conf->debug_log_file.len = 0;
+    conf->data_buffer_dir.data = NULL;
+    conf->data_buffer_dir.len = 0;
+    conf->instance_registry_dir.data = NULL;
+    conf->instance_registry_dir.len = 0;
     conf->abort_on_startup_error = NGX_CONF_UNSET;
-    conf->max_pool_size = (ngx_uint_t) NGX_CONF_UNSET;
-    conf->pool_idle_time = (ngx_uint_t) NGX_CONF_UNSET;
+    conf->max_pool_size = NGX_CONF_UNSET_UINT;
+    conf->pool_idle_time = NGX_CONF_UNSET_UINT;
+    conf->stat_throttle_rate = NGX_CONF_UNSET_UINT;
     conf->user_switching = NGX_CONF_UNSET;
+    conf->show_version_in_header = NGX_CONF_UNSET;
+    conf->turbocaching = NGX_CONF_UNSET;
     conf->default_user.data = NULL;
     conf->default_user.len  = 0;
     conf->default_group.data = NULL;
@@ -128,22 +145,42 @@ passenger_init_main_conf(ngx_conf_t *cf, void *conf_pointer)
         conf->debug_log_file.data = (u_char *) "";
     }
 
+    if (conf->data_buffer_dir.len == 0) {
+        conf->data_buffer_dir.data = (u_char *) "";
+    }
+
+    if (conf->instance_registry_dir.len == 0) {
+        conf->instance_registry_dir.data = (u_char *) "";
+    }
+
     if (conf->abort_on_startup_error == NGX_CONF_UNSET) {
         conf->abort_on_startup_error = 0;
     }
 
-    if (conf->max_pool_size == (ngx_uint_t) NGX_CONF_UNSET) {
+    if (conf->max_pool_size == NGX_CONF_UNSET_UINT) {
         conf->max_pool_size = DEFAULT_MAX_POOL_SIZE;
     }
 
-    if (conf->pool_idle_time == (ngx_uint_t) NGX_CONF_UNSET) {
+    if (conf->pool_idle_time == NGX_CONF_UNSET_UINT) {
         conf->pool_idle_time = DEFAULT_POOL_IDLE_TIME;
     }
 
+    if (conf->stat_throttle_rate == NGX_CONF_UNSET_UINT) {
+        conf->stat_throttle_rate = DEFAULT_STAT_THROTTLE_RATE;
+    }
+
     if (conf->user_switching == NGX_CONF_UNSET) {
         conf->user_switching = 1;
     }
 
+    if (conf->show_version_in_header == NGX_CONF_UNSET) {
+        conf->show_version_in_header = 1;
+    }
+
+    if (conf->turbocaching == NGX_CONF_UNSET) {
+        conf->turbocaching = 1;
+    }
+
     if (conf->default_user.len == 0) {
         conf->default_user.len  = sizeof(DEFAULT_WEB_APP_USER) - 1;
         conf->default_user.data = (u_char *) DEFAULT_WEB_APP_USER;
@@ -204,7 +241,6 @@ void *
 passenger_create_loc_conf(ngx_conf_t *cf)
 {
     passenger_loc_conf_t  *conf;
-    ngx_keyval_t          *kv;
 
     conf = ngx_pcalloc(cf->pool, sizeof(passenger_loc_conf_t));
     if (conf == NULL) {
@@ -236,29 +272,17 @@ passenger_create_loc_conf(ngx_conf_t *cf)
 
     conf->upstream_config.store = NGX_CONF_UNSET;
     conf->upstream_config.store_access = NGX_CONF_UNSET_UINT;
-    #if NGINX_VERSION_NUM >= 1007005
-        conf->upstream_config.next_upstream_tries = NGX_CONF_UNSET_UINT;
-    #endif
     conf->upstream_config.buffering = NGX_CONF_UNSET;
     conf->upstream_config.ignore_client_abort = NGX_CONF_UNSET;
-    #if NGINX_VERSION_NUM >= 1007007
-        conf->upstream_config.force_ranges = NGX_CONF_UNSET;
-    #endif
 
     conf->upstream_config.local = NGX_CONF_UNSET_PTR;
 
     conf->upstream_config.connect_timeout = NGX_CONF_UNSET_MSEC;
     conf->upstream_config.send_timeout = NGX_CONF_UNSET_MSEC;
     conf->upstream_config.read_timeout = NGX_CONF_UNSET_MSEC;
-    #if NGINX_VERSION_NUM >= 1007005
-        conf->upstream_config.next_upstream_timeout = NGX_CONF_UNSET_MSEC;
-    #endif
 
     conf->upstream_config.send_lowat = NGX_CONF_UNSET_SIZE;
     conf->upstream_config.buffer_size = NGX_CONF_UNSET_SIZE;
-    #if NGINX_VERSION_NUM >= 1007007
-        conf->upstream_config.limit_rate = NGX_CONF_UNSET_SIZE;
-    #endif
 
     conf->upstream_config.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
     conf->upstream_config.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
@@ -268,11 +292,7 @@ passenger_create_loc_conf(ngx_conf_t *cf)
     conf->upstream_config.pass_request_body = NGX_CONF_UNSET;
 
 #if (NGX_HTTP_CACHE)
-    #if NGINX_VERSION_NUM >= 1007009
-        conf->upstream_config.cache = NGX_CONF_UNSET;
-    #else
-        conf->upstream_config.cache = NGX_CONF_UNSET_PTR;
-    #endif
+    conf->upstream_config.cache = NGX_CONF_UNSET_PTR;
     conf->upstream_config.cache_min_uses = NGX_CONF_UNSET_UINT;
     conf->upstream_config.cache_bypass = NGX_CONF_UNSET_PTR;
     conf->upstream_config.no_cache = NGX_CONF_UNSET_PTR;
@@ -281,12 +301,6 @@ passenger_create_loc_conf(ngx_conf_t *cf)
         conf->upstream_config.cache_lock = NGX_CONF_UNSET;
         conf->upstream_config.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
     #endif
-    #if NGINX_VERSION_NUM >= 1007008
-        conf->upstream_config.cache_lock_age = NGX_CONF_UNSET_MSEC;
-    #endif
-    #if NGINX_VERSION_NUM >= 1006000
-        conf->upstream_config.cache_revalidate = NGX_CONF_UNSET;
-    #endif
 #endif
 
     conf->upstream_config.intercept_errors = NGX_CONF_UNSET;
@@ -294,39 +308,85 @@ passenger_create_loc_conf(ngx_conf_t *cf)
     conf->upstream_config.cyclic_temp_file = 0;
     conf->upstream_config.change_buffering = 1;
 
-    #define DEFINE_VAR_TO_PASS(header_name, var_name) \
-        kv = ngx_array_push(conf->vars_source);       \
-        kv->key.data = (u_char *) header_name;        \
-        kv->key.len  = strlen(header_name) + 1;       \
-        kv->value.data = (u_char *) var_name;         \
-        kv->value.len  = strlen(var_name) + 1
-
-    conf->vars_source = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
-    if (conf->vars_source == NULL) {
-        return NGX_CONF_ERROR;
-    }
-
-    DEFINE_VAR_TO_PASS("SCGI",            "1");
-    DEFINE_VAR_TO_PASS("QUERY_STRING",    "$query_string");
-    DEFINE_VAR_TO_PASS("REQUEST_METHOD",  "$request_method");
-    DEFINE_VAR_TO_PASS("SERVER_PROTOCOL", "$server_protocol");
-    DEFINE_VAR_TO_PASS("SERVER_SOFTWARE", "nginx/$nginx_version");
-    DEFINE_VAR_TO_PASS("REMOTE_ADDR",     "$remote_addr");
-    DEFINE_VAR_TO_PASS("REMOTE_PORT",     "$remote_port");
-    DEFINE_VAR_TO_PASS("SERVER_ADDR",     "$server_addr");
-    DEFINE_VAR_TO_PASS("SERVER_PORT",     "$server_port");
-
 #if NGINX_VERSION_NUM >= 1000010
     ngx_str_set(&conf->upstream_config.module, "passenger");
 #endif
 
+    conf->options_cache.data  = NULL;
+    conf->options_cache.len   = 0;
+    conf->env_vars_cache.data = NULL;
+    conf->env_vars_cache.len  = 0;
+
     return conf;
 }
 
-static void
+static ngx_int_t
 cache_loc_conf_options(ngx_conf_t *cf, passenger_loc_conf_t *conf)
 {
+    ngx_uint_t     i;
+    ngx_keyval_t  *env_vars;
+    size_t         unencoded_len;
+    u_char        *unencoded_buf;
+
     #include "CacheLocationConfig.c"
+
+    if (conf->env_vars != NULL) {
+        /* Cache env vars data as base64-serialized string.
+         * First, calculate the length of the unencoded data.
+         */
+
+        unencoded_len = 0;
+        env_vars = (ngx_keyval_t *) conf->env_vars->elts;
+
+        for (i = 0; i < conf->env_vars->nelts; i++) {
+            unencoded_len += env_vars[i].key.len + 1 + env_vars[i].value.len + 1;
+        }
+
+        /* Create the unecoded data. */
+
+        unencoded_buf = pos = (u_char *) malloc(unencoded_len);
+        if (unencoded_buf == NULL) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "cannot allocate buffer of %z bytes for environment variables data",
+                               unencoded_len);
+            return NGX_ERROR;
+        }
+
+        for (i = 0; i < conf->env_vars->nelts; i++) {
+            pos = ngx_copy(pos, env_vars[i].key.data, env_vars[i].key.len);
+            *pos = '\0';
+            pos++;
+
+            pos = ngx_copy(pos, env_vars[i].value.data, env_vars[i].value.len);
+            *pos = '\0';
+            pos++;
+        }
+
+        assert((size_t) (pos - unencoded_buf) == unencoded_len);
+
+        /* Create base64-serialized string. */
+
+        buf = ngx_palloc(cf->pool, modp_b64_encode_len(unencoded_len));
+        if (buf == NULL) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "cannot allocate buffer of %z bytes for base64 encoding",
+                               modp_b64_encode_len(unencoded_len));
+            return NGX_ERROR;
+        }
+        len = modp_b64_encode((char *) buf, (const char *) unencoded_buf, unencoded_len);
+        if (len == (size_t) -1) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "error during base64 encoding");
+            free(unencoded_buf);
+            return NGX_ERROR;
+        }
+
+        conf->env_vars_cache.data = buf;
+        conf->env_vars_cache.len = len;
+        free(unencoded_buf);
+    }
+
+    return NGX_OK;
 }
 
 char *
@@ -335,110 +395,40 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
     passenger_loc_conf_t         *prev = parent;
     passenger_loc_conf_t         *conf = child;
 
-    u_char                       *p;
     size_t                        size;
-    uintptr_t                    *code;
-    ngx_uint_t                    i;
-    ngx_str_t                    *prev_base_uris, *base_uri;
-    ngx_str_t                    *prev_union_station_filters, *union_station_filter;
-    ngx_keyval_t                 *src;
     ngx_hash_init_t               hash;
-    ngx_http_script_compile_t     sc;
-    ngx_http_script_copy_code_t  *copy;
 
     #include "MergeLocationConfig.c"
     if (prev->options_cache.data == NULL) {
-        cache_loc_conf_options(cf, prev);
-    }
-    cache_loc_conf_options(cf, conf);
-
-    if (prev->base_uris != NGX_CONF_UNSET_PTR) {
-        if (conf->base_uris == NGX_CONF_UNSET_PTR) {
-            conf->base_uris = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
-            if (conf->base_uris == NULL) {
-                return NGX_CONF_ERROR;
-            }
-        }
-
-        prev_base_uris = (ngx_str_t *) prev->base_uris->elts;
-        for (i = 0; i < prev->base_uris->nelts; i++) {
-            base_uri = (ngx_str_t *) ngx_array_push(conf->base_uris);
-            if (base_uri == NULL) {
-                return NGX_CONF_ERROR;
-            }
-            *base_uri = prev_base_uris[i];
-        }
-    }
-
-    if (prev->union_station_filters != NGX_CONF_UNSET_PTR) {
-        if (conf->union_station_filters == NGX_CONF_UNSET_PTR) {
-            conf->union_station_filters = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
-            if (conf->union_station_filters == NULL) {
-                return NGX_CONF_ERROR;
-            }
-        }
-
-        prev_union_station_filters = (ngx_str_t *) prev->union_station_filters->elts;
-        for (i = 0; i < prev->union_station_filters->nelts; i++) {
-            union_station_filter = (ngx_str_t *) ngx_array_push(conf->union_station_filters);
-            if (union_station_filter == NULL) {
-                return NGX_CONF_ERROR;
-            }
-            *union_station_filter = prev_union_station_filters[i];
+        if (cache_loc_conf_options(cf, prev) != NGX_OK) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "cannot create " PROGRAM_NAME " configuration cache");
+            return NGX_CONF_ERROR;
         }
     }
 
     /******************************/
     /******************************/
 
-    #if (NGX_HTTP_CACHE) && NGINX_VERSION_NUM >= 1007009
-        if (conf->upstream_config.store > 0) {
-            conf->upstream_config.cache = 0;
-        }
-        if (conf->upstream_config.cache > 0) {
-            conf->upstream_config.store = 0;
-        }
-    #endif
-
-    #if NGINX_VERSION_NUM >= 1007009
-        if (conf->upstream_config.store == NGX_CONF_UNSET) {
-            ngx_conf_merge_value(conf->upstream_config.store,
-                                      prev->upstream_config.store, 0);
+    if (conf->upstream_config.store != 0) {
+        ngx_conf_merge_value(conf->upstream_config.store,
+                                  prev->upstream_config.store, 0);
 
+        if (conf->upstream_config.store_lengths == NULL) {
             conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
             conf->upstream_config.store_values = prev->upstream_config.store_values;
         }
-    #else
-        if (conf->upstream_config.store != 0) {
-            ngx_conf_merge_value(conf->upstream_config.store,
-                                      prev->upstream_config.store, 0);
-
-            if (conf->upstream_config.store_lengths == NULL) {
-                conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
-                conf->upstream_config.store_values = prev->upstream_config.store_values;
-            }
-        }
-    #endif
+    }
 
     ngx_conf_merge_uint_value(conf->upstream_config.store_access,
                               prev->upstream_config.store_access, 0600);
 
-    #if NGINX_VERSION_NUM >= 1007005
-        ngx_conf_merge_uint_value(conf->upstream_config.next_upstream_tries,
-                                  prev->upstream_config.next_upstream_tries, 0);
-    #endif
-
     ngx_conf_merge_value(conf->upstream_config.buffering,
                          prev->upstream_config.buffering, 0);
 
     ngx_conf_merge_value(conf->upstream_config.ignore_client_abort,
                          prev->upstream_config.ignore_client_abort, 0);
 
-    #if NGINX_VERSION_NUM >= 1007007
-        ngx_conf_merge_value(conf->upstream_config.force_ranges,
-                             prev->upstream_config.force_ranges, 0);
-    #endif
-
     ngx_conf_merge_ptr_value(conf->upstream_config.local,
                              prev->upstream_config.local, NULL);
 
@@ -451,11 +441,6 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
     ngx_conf_merge_msec_value(conf->upstream_config.read_timeout,
                               prev->upstream_config.read_timeout, 12000000);
 
-    #if NGINX_VERSION_NUM >= 1007005
-        ngx_conf_merge_msec_value(conf->upstream_config.next_upstream_timeout,
-                                  prev->upstream_config.next_upstream_timeout, 0);
-    #endif
-
     ngx_conf_merge_size_value(conf->upstream_config.send_lowat,
                               prev->upstream_config.send_lowat, 0);
 
@@ -463,11 +448,6 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
                               prev->upstream_config.buffer_size,
                               16 * 1024);
 
-    #if NGINX_VERSION_NUM >= 1007007
-        ngx_conf_merge_size_value(conf->upstream_config.limit_rate,
-                                  prev->upstream_config.limit_rate, 0);
-    #endif
-
 
     ngx_conf_merge_bufs_value(conf->upstream_config.bufs, prev->upstream_config.bufs,
                               8, 16 * 1024);
@@ -582,42 +562,20 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 
 #if (NGX_HTTP_CACHE)
 
-    #if NGINX_VERSION_NUM >= 1007009
-        if (conf->upstream_config.cache == NGX_CONF_UNSET) {
-           ngx_conf_merge_value(conf->upstream_config.cache,
-                                prev->upstream_config.cache, 0);
+    ngx_conf_merge_ptr_value(conf->upstream_config.cache,
+                             prev->upstream_config.cache, NULL);
 
-           conf->upstream_config.cache_zone = prev->upstream_config.cache_zone;
-           conf->upstream_config.cache_value = prev->upstream_config.cache_value;
-        }
-
-        if (conf->upstream_config.cache_zone && conf->upstream_config.cache_zone->data == NULL) {
-            ngx_shm_zone_t  *shm_zone;
+    if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
+        ngx_shm_zone_t  *shm_zone;
 
-            shm_zone = conf->upstream_config.cache_zone;
+        shm_zone = conf->upstream_config.cache;
 
-            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                               "\"scgi_cache\" zone \"%V\" is unknown",
-                               &shm_zone->shm.name);
-
-            return NGX_CONF_ERROR;
-        }
-    #else
-        ngx_conf_merge_ptr_value(conf->upstream_config.cache,
-                                 prev->upstream_config.cache, NULL);
-
-        if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
-            ngx_shm_zone_t  *shm_zone;
-
-            shm_zone = conf->upstream_config.cache;
-
-            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                               "\"scgi_cache\" zone \"%V\" is unknown",
-                               &shm_zone->shm.name);
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "\"scgi_cache\" zone \"%V\" is unknown",
+                           &shm_zone->shm.name);
 
-            return NGX_CONF_ERROR;
-        }
-    #endif
+        return NGX_CONF_ERROR;
+    }
 
     ngx_conf_merge_uint_value(conf->upstream_config.cache_min_uses,
                               prev->upstream_config.cache_min_uses, 1);
@@ -663,16 +621,6 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
                               prev->upstream_config.cache_lock_timeout, 5000);
     #endif
 
-    #if NGINX_VERSION_NUM >= 1007008
-        ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_age,
-                                  prev->upstream_config.cache_lock_age, 5000);
-    #endif
-
-    #if NGINX_VERSION_NUM >= 1006000
-        ngx_conf_merge_value(conf->upstream_config.cache_revalidate,
-                             prev->upstream_config.cache_revalidate, 0);
-    #endif
-
 #endif
 
     ngx_conf_merge_value(conf->upstream_config.pass_request_headers,
@@ -699,97 +647,178 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
         conf->upstream_config.upstream = prev->upstream_config.upstream;
     }
 
-    if (conf->vars_source == NULL) {
+    conf->headers_hash_bucket_size = ngx_align(conf->headers_hash_bucket_size,
+                                               ngx_cacheline_size);
+    hash.max_size = conf->headers_hash_max_size;
+    hash.bucket_size = conf->headers_hash_bucket_size;
+    hash.name = "passenger_headers_hash";
+
+    if (merge_headers(cf, conf, prev) != NGX_OK) {
+        return NGX_CONF_ERROR;
+    }
+
+    if (cache_loc_conf_options(cf, conf) != NGX_OK) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "cannot create " PROGRAM_NAME " configuration cache");
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
+
+static ngx_int_t
+merge_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf, passenger_loc_conf_t *prev)
+{
+    u_char                       *p;
+    size_t                        size;
+    uintptr_t                    *code;
+    ngx_uint_t                    i;
+    ngx_array_t                   headers_names, headers_merged;
+    ngx_keyval_t                 *src, *s;
+    ngx_hash_key_t               *hk;
+    ngx_hash_init_t               hash;
+    ngx_http_script_compile_t     sc;
+    ngx_http_script_copy_code_t  *copy;
+
+    if (conf->headers_source == NULL) {
         conf->flushes = prev->flushes;
-        conf->vars_len = prev->vars_len;
-        conf->vars = prev->vars;
-        conf->vars_source = prev->vars_source;
+        conf->headers_set_len = prev->headers_set_len;
+        conf->headers_set = prev->headers_set;
+        conf->headers_set_hash = prev->headers_set_hash;
+        conf->headers_source = prev->headers_source;
+    }
+
+    if (conf->headers_set_hash.buckets
+#if (NGX_HTTP_CACHE)
+        && ((conf->upstream_config.cache == NULL) == (prev->upstream_config.cache == NULL))
+#endif
+       )
+    {
+        return NGX_OK;
+    }
 
-        if (conf->vars_source == NULL) {
-            return NGX_CONF_OK;
+
+    if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
+        != NGX_OK)
+    {
+        return NGX_ERROR;
+    }
+
+    if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
+        != NGX_OK)
+    {
+        return NGX_ERROR;
+    }
+
+    if (conf->headers_source == NULL) {
+        conf->headers_source = ngx_array_create(cf->pool, 4,
+                                                sizeof(ngx_keyval_t));
+        if (conf->headers_source == NULL) {
+            return NGX_ERROR;
         }
     }
 
-    conf->vars_len = ngx_array_create(cf->pool, 64, 1);
-    if (conf->vars_len == NULL) {
-        return NGX_CONF_ERROR;
+    conf->headers_set_len = ngx_array_create(cf->pool, 64, 1);
+    if (conf->headers_set_len == NULL) {
+        return NGX_ERROR;
     }
 
-    conf->vars = ngx_array_create(cf->pool, 512, 1);
-    if (conf->vars == NULL) {
-        return NGX_CONF_ERROR;
+    conf->headers_set = ngx_array_create(cf->pool, 512, 1);
+    if (conf->headers_set == NULL) {
+        return NGX_ERROR;
     }
 
-    src = conf->vars_source->elts;
-    for (i = 0; i < conf->vars_source->nelts; i++) {
 
-        if (ngx_http_script_variables_count(&src[i].value) == 0) {
-            copy = ngx_array_push_n(conf->vars_len,
-                                    sizeof(ngx_http_script_copy_code_t));
-            if (copy == NULL) {
-                return NGX_CONF_ERROR;
-            }
+    src = conf->headers_source->elts;
+    for (i = 0; i < conf->headers_source->nelts; i++) {
 
-            copy->code = (ngx_http_script_code_pt)
-                                                  ngx_http_script_copy_len_code;
-            copy->len = src[i].key.len;
+        s = ngx_array_push(&headers_merged);
+        if (s == NULL) {
+            return NGX_ERROR;
+        }
+
+        *s = src[i];
+    }
+
+
+    src = headers_merged.elts;
+    for (i = 0; i < headers_merged.nelts; i++) {
 
+        hk = ngx_array_push(&headers_names);
+        if (hk == NULL) {
+            return NGX_ERROR;
+        }
+
+        hk->key = src[i].key;
+        hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
+        hk->value = (void *) 1;
+
+        if (src[i].value.len == 0) {
+            continue;
+        }
 
-            copy = ngx_array_push_n(conf->vars_len,
+        if (ngx_http_script_variables_count(&src[i].value) == 0) {
+            copy = ngx_array_push_n(conf->headers_set_len,
                                     sizeof(ngx_http_script_copy_code_t));
             if (copy == NULL) {
-                return NGX_CONF_ERROR;
+                return NGX_ERROR;
             }
 
             copy->code = (ngx_http_script_code_pt)
                                                  ngx_http_script_copy_len_code;
-            copy->len = src[i].value.len;
+            copy->len = src[i].key.len + sizeof(": ") - 1
+                        + src[i].value.len + sizeof(CRLF) - 1;
 
 
             size = (sizeof(ngx_http_script_copy_code_t)
-                       + src[i].key.len + src[i].value.len
+                       + src[i].key.len + sizeof(": ") - 1
+                       + src[i].value.len + sizeof(CRLF) - 1
                        + sizeof(uintptr_t) - 1)
                     & ~(sizeof(uintptr_t) - 1);
 
-            copy = ngx_array_push_n(conf->vars, size);
+            copy = ngx_array_push_n(conf->headers_set, size);
             if (copy == NULL) {
-                return NGX_CONF_ERROR;
+                return NGX_ERROR;
             }
 
             copy->code = ngx_http_script_copy_code;
-            copy->len = src[i].key.len + src[i].value.len;
+            copy->len = src[i].key.len + sizeof(": ") - 1
+                        + src[i].value.len + sizeof(CRLF) - 1;
 
             p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
 
             p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
-            ngx_memcpy(p, src[i].value.data, src[i].value.len);
+            *p++ = ':'; *p++ = ' ';
+            p = ngx_cpymem(p, src[i].value.data, src[i].value.len);
+            *p++ = CR; *p = LF;
 
         } else {
-            copy = ngx_array_push_n(conf->vars_len,
+            copy = ngx_array_push_n(conf->headers_set_len,
                                     sizeof(ngx_http_script_copy_code_t));
             if (copy == NULL) {
-                return NGX_CONF_ERROR;
+                return NGX_ERROR;
             }
 
             copy->code = (ngx_http_script_code_pt)
                                                  ngx_http_script_copy_len_code;
-            copy->len = src[i].key.len;
+            copy->len = src[i].key.len + sizeof(": ") - 1;
 
 
             size = (sizeof(ngx_http_script_copy_code_t)
-                    + src[i].key.len + sizeof(uintptr_t) - 1)
+                    + src[i].key.len + sizeof(": ") - 1 + sizeof(uintptr_t) - 1)
                     & ~(sizeof(uintptr_t) - 1);
 
-            copy = ngx_array_push_n(conf->vars, size);
+            copy = ngx_array_push_n(conf->headers_set, size);
             if (copy == NULL) {
-                return NGX_CONF_ERROR;
+                return NGX_ERROR;
             }
 
             copy->code = ngx_http_script_copy_code;
-            copy->len = src[i].key.len;
+            copy->len = src[i].key.len + sizeof(": ") - 1;
 
             p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
-            ngx_memcpy(p, src[i].key.data, src[i].key.len);
+            p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
+            *p++ = ':'; *p = ' ';
 
 
             ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
@@ -797,45 +826,154 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
             sc.cf = cf;
             sc.source = &src[i].value;
             sc.flushes = &conf->flushes;
-            sc.lengths = &conf->vars_len;
-            sc.values = &conf->vars;
+            sc.lengths = &conf->headers_set_len;
+            sc.values = &conf->headers_set;
 
             if (ngx_http_script_compile(&sc) != NGX_OK) {
-                return NGX_CONF_ERROR;
+                return NGX_ERROR;
+            }
+
+
+            copy = ngx_array_push_n(conf->headers_set_len,
+                                    sizeof(ngx_http_script_copy_code_t));
+            if (copy == NULL) {
+                return NGX_ERROR;
+            }
+
+            copy->code = (ngx_http_script_code_pt)
+                                                 ngx_http_script_copy_len_code;
+            copy->len = sizeof(CRLF) - 1;
+
+
+            size = (sizeof(ngx_http_script_copy_code_t)
+                    + sizeof(CRLF) - 1 + sizeof(uintptr_t) - 1)
+                    & ~(sizeof(uintptr_t) - 1);
+
+            copy = ngx_array_push_n(conf->headers_set, size);
+            if (copy == NULL) {
+                return NGX_ERROR;
             }
+
+            copy->code = ngx_http_script_copy_code;
+            copy->len = sizeof(CRLF) - 1;
+
+            p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
+            *p++ = CR; *p = LF;
         }
 
-        code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
+        code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
         if (code == NULL) {
-            return NGX_CONF_ERROR;
+            return NGX_ERROR;
         }
 
         *code = (uintptr_t) NULL;
 
-
-        code = ngx_array_push_n(conf->vars, sizeof(uintptr_t));
+        code = ngx_array_push_n(conf->headers_set, sizeof(uintptr_t));
         if (code == NULL) {
-            return NGX_CONF_ERROR;
+            return NGX_ERROR;
         }
 
         *code = (uintptr_t) NULL;
     }
 
-    code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
+    code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
     if (code == NULL) {
-        return NGX_CONF_ERROR;
+        return NGX_ERROR;
     }
 
     *code = (uintptr_t) NULL;
 
-    return NGX_CONF_OK;
+
+    hash.hash = &conf->headers_set_hash;
+    hash.key = ngx_hash_key_lc;
+    hash.max_size = conf->headers_hash_max_size;
+    hash.bucket_size = conf->headers_hash_bucket_size;
+    hash.name = "passenger_headers_hash";
+    hash.pool = cf->pool;
+    hash.temp_pool = NULL;
+
+    return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
+}
+
+static ngx_int_t
+merge_string_array(ngx_conf_t *cf, ngx_array_t **prev, ngx_array_t **conf)
+{
+    ngx_str_t  *prev_elems, *elem;
+    ngx_uint_t  i;
+
+    if (*prev != NGX_CONF_UNSET_PTR) {
+        if (*conf == NGX_CONF_UNSET_PTR) {
+            *conf = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
+            if (*conf == NULL) {
+                return NGX_ERROR;
+            }
+        }
+
+        prev_elems = (ngx_str_t *) (*prev)->elts;
+        for (i = 0; i < (*prev)->nelts; i++) {
+            elem = (ngx_str_t *) ngx_array_push(*conf);
+            if (elem == NULL) {
+                return NGX_ERROR;
+            }
+            *elem = prev_elems[i];
+        }
+    }
+
+    return NGX_OK;
+}
+
+static int
+string_keyval_has_key(ngx_array_t *table, ngx_str_t *key)
+{
+    ngx_keyval_t  *elems;
+    ngx_uint_t     i;
+
+    elems = (ngx_keyval_t *) table->elts;
+    for (i = 0; i < table->nelts; i++) {
+        if (elems[i].key.len == key->len
+         && memcmp(elems[i].key.data, key->data, key->len) == 0)
+        {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static ngx_int_t
+merge_string_keyval_table(ngx_conf_t *cf, ngx_array_t **prev, ngx_array_t **conf)
+{
+    ngx_keyval_t  *prev_elems, *elem;
+    ngx_uint_t     i;
+
+    if (*prev != NULL) {
+        if (*conf == NULL) {
+            *conf = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
+            if (*conf == NULL) {
+                return NGX_ERROR;
+            }
+        }
+
+        prev_elems = (ngx_keyval_t *) (*prev)->elts;
+        for (i = 0; i < (*prev)->nelts; i++) {
+            if (!string_keyval_has_key(*conf, &prev_elems[i].key)) {
+                elem = (ngx_keyval_t *) ngx_array_push(*conf);
+                if (elem == NULL) {
+                    return NGX_ERROR;
+                }
+                *elem = prev_elems[i];
+            }
+        }
+    }
+
+    return NGX_OK;
 }
 
 #ifndef PASSENGER_IS_ENTERPRISE
 static char *
 passenger_enterprise_only(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
     return ": this feature is only available in Phusion Passenger Enterprise. "
-        "You are currently running the open source Phusion Passenger Enterprise. "
+        "You are currently running the open source Phusion Passenger. "
         "Please learn more about and/or buy Phusion Passenger Enterprise at https://www.phusionpassenger.com/enterprise ;";
 }
 #endif
@@ -1032,11 +1170,18 @@ const ngx_command_t passenger_commands[] = {
       offsetof(passenger_main_conf_t, debug_log_file),
       NULL },
 
-    { ngx_string("passenger_temp_dir"),
+    { ngx_string("passenger_data_buffer_dir"),
       NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
       ngx_conf_set_str_slot,
       NGX_HTTP_MAIN_CONF_OFFSET,
-      offsetof(passenger_main_conf_t, temp_dir),
+      offsetof(passenger_main_conf_t, data_buffer_dir),
+      NULL },
+
+    { ngx_string("passenger_instance_registry_dir"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_str_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, instance_registry_dir),
       NULL },
 
     { ngx_string("passenger_pre_start"),
@@ -1067,6 +1212,27 @@ const ngx_command_t passenger_commands[] = {
       offsetof(passenger_main_conf_t, pool_idle_time),
       NULL },
 
+    { ngx_string("passenger_stat_throttle_rate"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_num_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, stat_throttle_rate),
+      NULL },
+
+    { ngx_string("passenger_show_version_in_header"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, show_version_in_header),
+      NULL },
+
+    { ngx_string("passenger_turbocaching"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, turbocaching),
+      NULL },
+
     { ngx_string("passenger_user_switching"),
       NGX_HTTP_MAIN_CONF | NGX_CONF_FLAG,
       ngx_conf_set_flag_slot,