passenger 3.0.7 → 3.0.8

data/ext/nginx/Configuration.c

@@ -41,12 +41,12 @@
 
 static ngx_str_t headers_to_hide[] = {
     /* NOTE: Do not hide the "Status" header; some broken HTTP clients
-     * expect this header. See http://tinyurl.com/87rezm
+     * expect this header. http://code.google.com/p/phusion-passenger/issues/detail?id=177
      */
     ngx_string("X-Accel-Expires"),
     ngx_string("X-Accel-Redirect"),
     ngx_string("X-Accel-Limit-Rate"),
-    ngx_string("X-Accel-Buffer"),
+    ngx_string("X-Accel-Buffering"),
     ngx_null_string
 };
 
@@ -261,9 +261,6 @@ passenger_create_loc_conf(ngx_conf_t *cf)
      *     conf->upstream_config.location = NULL;
      *     conf->upstream_config.store_lengths = NULL;
      *     conf->upstream_config.store_values = NULL;
-     *
-     *     conf->index.len = 0;
-     *     conf->index.data = NULL;
      */
 
     conf->enabled = NGX_CONF_UNSET;
@@ -319,6 +316,7 @@ passenger_create_loc_conf(ngx_conf_t *cf)
     conf->upstream_config.intercept_errors = NGX_CONF_UNSET;
 
     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);       \
@@ -341,7 +339,6 @@ passenger_create_loc_conf(ngx_conf_t *cf)
     DEFINE_VAR_TO_PASS("REMOTE_PORT",     "$remote_port");
     DEFINE_VAR_TO_PASS("SERVER_ADDR",     "$server_addr");
     DEFINE_VAR_TO_PASS("SERVER_PORT",     "$server_port");
-    DEFINE_VAR_TO_PASS("SERVER_NAME",     "$server_name");
 
     return conf;
 }
@@ -463,7 +460,7 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 
     if (conf->upstream_config.bufs.num < 2) {
         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                           "there must be at least 2 \"scgi_buffers\"");
+                           "there must be at least 2 \"passenger_buffers\"");
         return NGX_CONF_ERROR;
     }
 
@@ -487,9 +484,9 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 
     if (conf->upstream_config.busy_buffers_size < size) {
         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-             "\"scgi_busy_buffers_size\" must be equal or bigger than "
-             "maximum of the value of \"scgi_buffer_size\" and "
-             "one of the \"scgi_buffers\"");
+             "\"passenger_busy_buffers_size\" must be equal or bigger than "
+             "maximum of the value of \"passenger_buffer_size\" and "
+             "one of the \"passenger_buffers\"");
 
         return NGX_CONF_ERROR;
     }
@@ -498,8 +495,8 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
         > (conf->upstream_config.bufs.num - 1) * conf->upstream_config.bufs.size)
     {
         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-             "\"scgi_busy_buffers_size\" must be less than "
-             "the size of all \"scgi_buffers\" minus one buffer");
+             "\"passenger_busy_buffers_size\" must be less than "
+             "the size of all \"passenger_buffers\" minus one buffer");
 
         return NGX_CONF_ERROR;
     }
@@ -518,9 +515,9 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 
     if (conf->upstream_config.temp_file_write_size < size) {
         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-             "\"scgi_temp_file_write_size\" must be equal or bigger than "
-             "maximum of the value of \"scgi_buffer_size\" and "
-             "one of the \"scgi_buffers\"");
+             "\"passenger_temp_file_write_size\" must be equal or bigger than "
+             "maximum of the value of \"passenger_buffer_size\" and "
+             "one of the \"passenger_buffers\"");
 
         return NGX_CONF_ERROR;
     }
@@ -541,10 +538,10 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
         && conf->upstream_config.max_temp_file_size < size)
     {
         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-             "\"scgi_max_temp_file_size\" must be equal to zero to disable "
+             "\"passenger_max_temp_file_size\" must be equal to zero to disable "
              "the temporary files usage or must be equal or bigger than "
-             "maximum of the value of \"scgi_buffer_size\" and "
-             "one of the \"scgi_buffers\"");
+             "maximum of the value of \"passenger_buffer_size\" and "
+             "one of the \"passenger_buffers\"");
 
         return NGX_CONF_ERROR;
     }
@@ -576,8 +573,6 @@ passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
 
 
 
-    ngx_conf_merge_str_value(conf->index, prev->index, "");
-
     if (conf->upstream_config.hide_headers == NULL
         && conf->upstream_config.pass_headers == NULL)
     {
@@ -951,131 +946,6 @@ set_null_terminated_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     return NGX_CONF_OK;
 }
 
-#if 0
-static char *
-ngx_http_scgi_lowat_check(ngx_conf_t *cf, void *post, void *data)
-{
-#if (NGX_FREEBSD)
-    ssize_t *np = data;
-
-    if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
-        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                           "\"scgi_send_lowat\" must be less than %d "
-                           "(sysctl net.inet.tcp.sendspace)",
-                           ngx_freebsd_net_inet_tcp_sendspace);
-
-        return NGX_CONF_ERROR;
-    }
-
-#elif !(NGX_HAVE_SO_SNDLOWAT)
-    ssize_t *np = data;
-
-    ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
-                       "\"scgi_send_lowat\" is not supported, ignored");
-
-    *np = 0;
-
-#endif
-
-    return NGX_CONF_OK;
-}
-
-static char *
-ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
-{
-    passenger_loc_conf_t       *slcf = conf;
-
-    ngx_str_t                  *value;
-    ngx_http_script_compile_t   sc;
-
-    if (slcf->upstream.store != NGX_CONF_UNSET || slcf->upstream.store_lengths)
-    {
-        return "is duplicate";
-    }
-
-    value = cf->args->elts;
-
-    if (ngx_strcmp(value[1].data, "on") == 0) {
-        slcf->upstream.store = 1;
-        return NGX_CONF_OK;
-    }
-
-    if (ngx_strcmp(value[1].data, "off") == 0) {
-        slcf->upstream.store = 0;
-        return NGX_CONF_OK;
-    }
-
-    /* include the terminating '\0' into script */
-    value[1].len++;
-
-    ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
-
-    sc.cf = cf;
-    sc.source = &value[1];
-    sc.lengths = &slcf->upstream.store_lengths;
-    sc.values = &slcf->upstream.store_values;
-    sc.variables = ngx_http_script_variables_count(&value[1]);
-    sc.complete_lengths = 1;
-    sc.complete_values = 1;
-
-    if (ngx_http_script_compile(&sc) != NGX_OK) {
-        return NGX_CONF_ERROR;
-    }
-
-    return NGX_CONF_OK;
-}
-
-char *
-ngx_scgi_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
-{
-    /*
-     * Like ngx_conf_set_keyval_slot but keeps the \0 at the end of
-     * the strings.
-     */
-
-    char  *p = conf;
-
-    ngx_str_t         *value;
-    ngx_array_t      **a;
-    ngx_keyval_t      *kv;
-    ngx_conf_post_t   *post;
-
-    a = (ngx_array_t **) (p + cmd->offset);
-
-    if (*a == NULL) {
-        *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
-        if (*a == NULL) {
-            return NGX_CONF_ERROR;
-        }
-    }
-
-    kv = ngx_array_push(*a);
-    if (kv == NULL) {
-        return NGX_CONF_ERROR;
-    }
-
-    value = cf->args->elts;
-
-    /* strings are null terminated */
-    value[1].len += 1;
-    value[2].len += 1;
-
-    kv->key = value[1];
-    kv->value = value[2];
-
-    if (cmd->post) {
-        post = cmd->post;
-        return post->post_handler(cf, post, kv);
-    }
-
-    return NGX_CONF_OK;
-}
-
-
-static ngx_conf_post_t  ngx_http_scgi_lowat_post =
-    { ngx_http_scgi_lowat_check };
-
-#endif /* 0 */
 
 const ngx_command_t passenger_commands[] = {
 
@@ -1331,6 +1201,27 @@ const ngx_command_t passenger_commands[] = {
       offsetof(passenger_loc_conf_t, upstream_config.buffering),
       NULL },
 
+    { ngx_string("passenger_buffer_size"),
+      NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(passenger_loc_conf_t, upstream_config.buffer_size),
+      NULL },
+
+    { ngx_string("passenger_buffers"),
+      NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_TAKE2,
+      ngx_conf_set_bufs_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(passenger_loc_conf_t, upstream_config.bufs),
+      NULL },
+
+    { ngx_string("passenger_busy_buffers_size"),
+      NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(passenger_loc_conf_t, upstream_config.busy_buffers_size_conf),
+      NULL },
+
     { ngx_string("passenger_spawn_method"),
       NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE1,
       ngx_conf_set_str_slot,
@@ -1385,143 +1276,6 @@ const ngx_command_t passenger_commands[] = {
       offsetof(passenger_loc_conf_t, spawn_method),
       NULL },
 
-/*
-
-    { ngx_string("scgi_index"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_str_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, index),
-      NULL },
-
-    { ngx_string("scgi_store"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_http_scgi_store,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      0,
-      NULL },
-
-    { ngx_string("scgi_store_access"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
-      ngx_conf_set_access_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.store_access),
-      NULL },
-
-    { ngx_string("scgi_ignore_client_abort"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
-      ngx_conf_set_flag_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.ignore_client_abort),
-      NULL },
-
-    { ngx_string("scgi_connect_timeout"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_msec_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.connect_timeout),
-      NULL },
-
-    { ngx_string("scgi_send_timeout"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_msec_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.send_timeout),
-      NULL },
-
-    { ngx_string("scgi_send_lowat"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_size_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.send_lowat),
-      &ngx_http_scgi_lowat_post },
-
-    { ngx_string("scgi_buffer_size"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_size_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.buffer_size),
-      NULL },
-
-    { ngx_string("scgi_pass_request_headers"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
-      ngx_conf_set_flag_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.pass_request_headers),
-      NULL },
-
-    { ngx_string("scgi_pass_request_body"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
-      ngx_conf_set_flag_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.pass_request_body),
-      NULL },
-
-    { ngx_string("scgi_intercept_errors"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
-      ngx_conf_set_flag_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.intercept_errors),
-      NULL },
-
-    { ngx_string("scgi_read_timeout"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_msec_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.read_timeout),
-      NULL },
-
-    { ngx_string("scgi_buffers"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
-      ngx_conf_set_bufs_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.bufs),
-      NULL },
-
-    { ngx_string("scgi_busy_buffers_size"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_size_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.busy_buffers_size_conf),
-      NULL },
-
-    { ngx_string("scgi_temp_path"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
-      ngx_conf_set_path_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.temp_path),
-      (void *) ngx_garbage_collector_temp_handler },
-
-    { ngx_string("scgi_max_temp_file_size"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_size_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.max_temp_file_size_conf),
-      NULL },
-
-    { ngx_string("scgi_temp_file_write_size"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_size_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.temp_file_write_size_conf),
-      NULL },
-
-    { ngx_string("scgi_var"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
-      ngx_scgi_set_keyval_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, vars_source),
-      NULL },
-
-    { ngx_string("scgi_hide_header"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
-      ngx_conf_set_str_array_slot,
-      NGX_HTTP_LOC_CONF_OFFSET,
-      offsetof(passenger_loc_conf_t, upstream.hide_headers),
-      NULL },
-
-*/
-
       ngx_null_command
 };
 

data/ext/nginx/ContentHandler.c

@@ -321,12 +321,14 @@ create_request(ngx_http_request_t *r)
     size_t                         len, size, key_len, val_len, content_length;
     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;
     u_char                         min_instances_string[12];
     u_char                         framework_spawner_idle_time_string[12];
     u_char                         app_spawner_idle_time_string[12];
     u_char                        *end;
+    void                          *tmp;
     ngx_uint_t                     i, n;
     ngx_buf_t                     *b;
     ngx_chain_t                   *cl, *body;
@@ -412,6 +414,15 @@ create_request(ngx_http_request_t *r)
         len += 1 + r->args.len;
     }
     
+    /* SERVER_NAME; must be equal to HTTP_HOST without the port part */
+    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);
+    }
+    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) {
@@ -637,6 +648,12 @@ create_request(ngx_http_request_t *r)
     }
     b->last = ngx_copy(b->last, "", 1);
     
+    /* SERVER_NAME */
+    b->last = ngx_copy(b->last, "SERVER_NAME", sizeof("SERVER_NAME"));
+    b->last = ngx_copy(b->last, r->headers_in.host->value.data,
+                       server_name_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) {

data/ext/nginx/HelperAgent.cpp

@@ -28,8 +28,9 @@
 #include <sys/stat.h>
 #include <sys/un.h>
 #include <cstring>
+#include <cassert>
+#include <cerrno>
 #include <unistd.h>
-#include <errno.h>
 #include <limits.h>
 #include <pwd.h>
 #include <grp.h>
@@ -44,7 +45,6 @@
 #include "oxt/system_calls.hpp"
 
 #include "ScgiRequestParser.h"
-#include "HttpStatusExtractor.h"
 
 #include "AgentBase.h"
 #include "HelperAgent/BacktracesServer.h"
@@ -60,6 +60,9 @@
 #include "Exceptions.h"
 #include "Utils.h"
 #include "Utils/Timer.h"
+#include <Utils/Dechunker.h>
+#include <Utils/HttpHeaderBufferer.h>
+#include <Utils/StreamBoyerMooreHorspool.h>
 
 using namespace boost;
 using namespace oxt;
@@ -67,6 +70,9 @@ using namespace Passenger;
 
 #define REQUEST_SOCKET_PASSWORD_SIZE     64
 
+static StreamBMH_Occ statusFinder_occ;
+static StreamBMH_Occ transferEncodingFinder_occ;
+
 struct ClientDisconnectedException { };
 
 class ExitHandler: public MessageServer::Handler {
@@ -150,6 +156,267 @@ private:
 	 */
 	Timer inactivityTimer;
 	
+	int currentClient;
+	HttpHeaderBufferer headerBufferer;
+	union {
+		struct StreamBMH ctx;
+		char padding[SBMH_SIZE(sizeof("Status:") - 1)];
+	} statusFinder;
+	union {
+		struct StreamBMH ctx;
+		char padding[SBMH_SIZE(sizeof("Transfer-Encoding:") - 1)];
+	} transferEncodingFinder;
+	
+	/** Given a substring containing the start of the header value,
+	 * extracts the substring that contains a single header value.
+	 *
+	 *   const char *data =
+	 *      "Status: 200 OK\r\n"
+	 *      "Foo: bar\r\n";
+	 *   extractHeaderValue(data + strlen("Status:"), strlen(data) - strlen("Status:"));
+	 *      // "200 OK"
+	 */
+	static StaticString extractHeaderValue(const char *data, size_t size) {
+		const char *start = data;
+		const char *end   = data + size;
+		const char *terminator;
+		
+		while (start < end && *start == ' ') {
+			start++;
+		}
+		
+		terminator = (const char *) memchr(start, '\r', end - start);
+		if (terminator == NULL) {
+			return StaticString();
+		} else {
+			return StaticString(start, terminator - start);
+		}
+	}
+	
+	StaticString extractAndSanitizeHttpStatus(const StaticString &header, char buf[32]) {
+		StaticString status;
+		size_t accepted;
+		
+		sbmh_reset(&statusFinder.ctx);
+		accepted = sbmh_feed(&statusFinder.ctx,
+			&statusFinder_occ,
+			(const unsigned char *) "Status:",
+			sizeof("Status:") - 1,
+			(const unsigned char *) header.data(),
+			header.size());
+		if (statusFinder.ctx.found) {
+			status = extractHeaderValue(header.data() + accepted,
+				header.size() - accepted);
+			if (status.find(' ') == string::npos) {
+				int code = stringToInt(status);
+				switch (code) {
+				case 100:
+					status = "100 Continue";
+					break;
+				case 101:
+					status = "101 Switching Protocols";
+					break;
+				case 102:
+					status = "102 Processing";
+					break;
+				case 200:
+					status = "200 OK";
+					break;
+				case 201:
+					status = "201 Created";
+					break;
+				case 202:
+					status = "202 Accepted";
+					break;
+				case 203:
+					status = "203 Non-Authoritative Information";
+					break;
+				case 204:
+					status = "204 No Content";
+					break;
+				case 205:
+					status = "205 Reset Content";
+					break;
+				case 206:
+					status = "206 Partial Content";
+					break;
+				case 207:
+					status = "207 Multi-Status";
+					break;
+				case 300:
+					status = "300 Multiple Choices";
+					break;
+				case 301:
+					status = "301 Moved Permanently";
+					break;
+				case 302:
+					status = "302 Found";
+					break;
+				case 303:
+					status = "303 See Other";
+					break;
+				case 304:
+					status = "304 Not Modified";
+					break;
+				case 305:
+					status = "305 Use Proxy";
+					break;
+				case 306:
+					status = "306 Switch Proxy";
+					break;
+				case 307:
+					status = "307 Temporary Redirect";
+					break;
+				case 308:
+					// Google Gears: http://code.google.com/p/gears/wiki/ResumableHttpRequestsProposal
+					status = "308 Resume Incomplete";
+					break;
+				case 400:
+					status = "400 Bad Request";
+					break;
+				case 401:
+					status = "401 Unauthorized";
+					break;
+				case 402:
+					status = "402 Payment Required";
+					break;
+				case 403:
+					status = "403 Forbidden";
+					break;
+				case 404:
+					status = "404 Not Found";
+					break;
+				case 405:
+					status = "405 Method Not Allowed";
+					break;
+				case 406:
+					status = "406 Not Acceptable";
+					break;
+				case 407:
+					status = "407 Proxy Authentication Required";
+					break;
+				case 408:
+					status = "408 Request Timeout";
+					break;
+				case 409:
+					status = "409 Conflict";
+					break;
+				case 410:
+					status = "410 Gone";
+					break;
+				case 411:
+					status = "411 Length Required";
+					break;
+				case 412:
+					status = "412 Precondition Failed";
+					break;
+				case 413:
+					status = "413 Request Entity Too Large";
+					break;
+				case 414:
+					status = "414 Request-URI Too Long";
+					break;
+				case 415:
+					status = "415 Unsupported Media Type";
+					break;
+				case 416:
+					status = "416 Requested Range Not Satisfiable";
+					break;
+				case 417:
+					status = "417 Expectation Failed";
+					break;
+				case 418:
+					status = "418 Not A Funny April Fools Joke";
+					break;
+				case 422:
+					status = "422 Unprocessable Entity";
+					break;
+				case 423:
+					status = "423 Locked";
+					break;
+				case 424:
+					status = "424 Unordered Collection";
+					break;
+				case 426:
+					status = "426 Upgrade Required";
+					break;
+				case 449:
+					status = "449 Retry With";
+					break;
+				case 450:
+					status = "450 Blocked";
+					break;
+				case 500:
+					status = "500 Internal Server Error";
+					break;
+				case 501:
+					status = "501 Not Implemented";
+					break;
+				case 502:
+					status = "502 Bad Gateway";
+					break;
+				case 503:
+					status = "503 Service Unavailable";
+					break;
+				case 504:
+					status = "504 Gateway Timeout";
+					break;
+				case 505:
+					status = "505 HTTP Version Not Supported";
+					break;
+				case 506:
+					status = "506 Variant Also Negotiates";
+					break;
+				case 507:
+					status = "507 Insufficient Storage";
+					break;
+				case 509:
+					status = "509 Bandwidth Limit Exceeded";
+					break;
+				case 510:
+					status = "510 Not Extended";
+					break;
+				default:
+					snprintf(buf, 32,
+						"%d Unknown Status Code",
+						code);
+					buf[31] = '\0';
+					status = buf;
+				}
+			}
+		} else {
+			status = "200 OK";
+		}
+		
+		return status;
+	}
+	
+	bool detectChunkedTransferEncodingAndRemoveHeader(const StaticString &header) {
+		size_t accepted;
+		
+		sbmh_reset(&transferEncodingFinder.ctx);
+		accepted = sbmh_feed(&transferEncodingFinder.ctx,
+			&transferEncodingFinder_occ,
+			(const unsigned char *) "Transfer-Encoding:",
+			sizeof("Transfer-Encoding:") - 1,
+			(const unsigned char *) header.data(),
+			header.size());
+		if (transferEncodingFinder.ctx.found) {
+			StaticString value = extractHeaderValue(header.data() + accepted,
+				header.size() - accepted);
+			if (value == "chunked") {
+				// Remove Transfer-Encoding header.
+				char *tmp = (char *) (header.data() + accepted - 2);
+				*tmp = '_';
+				return true;
+			} else {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+	
 	/**
 	 * Attempts to accept a connection made by the client.
 	 *
@@ -317,52 +584,114 @@ private:
 		const AnalyticsLogPtr &log)
 	{
 		TRACE_POINT();
-		HttpStatusExtractor ex;
 		int stream = session->getStream();
 		int eof = false;
-		char buf[1024 * 32];
+		char buf[1024 * 24];
+		size_t accepted;
 		ssize_t size;
+		bool chunked = false;
+		Dechunker dechunker;
 		
-		/* Read data from the backend process until we're able to
-		 * extract the HTTP status line from it.
+		currentClient = clientFd;
+		
+		/* Read data from the backend process until we
+		 * have at least an entire response header, or
+		 * until some error occurred.
 		 */
-		while (!eof) {
+		headerBufferer.reset();
+		while (!eof && headerBufferer.acceptingInput()) {
 			UPDATE_TRACE_POINT();
 			size = syscalls::read(stream, buf, sizeof(buf));
 			if (size == 0) {
 				eof = true;
 			} else if (size == -1) {
 				throw SystemException("Cannot read response from backend process", errno);
-			} else if (ex.feed(buf, size)) {
-				/* We now have an HTTP status line. Send back
-				 * a proper HTTP response, then exit this while
-				 * loop and continue with forwarding the rest
-				 * of the response data.
-				 */
+			} else {
+				accepted = headerBufferer.feed(buf, size);
+			}
+		}
+		
+		/* Now process the response header as well as whatever part of the
+		 * response body we've already received.
+		 */
+		if (!headerBufferer.acceptingInput() && !headerBufferer.hasError()) {
+			UPDATE_TRACE_POINT();
+			assert(!eof);
+			StaticString headerData = headerBufferer.getData();
+			StaticString nonHeaderData(buf + accepted, size - accepted);
+			StaticString status;
+			char statusTmp[32];
+			
+			status = extractAndSanitizeHttpStatus(headerData, statusTmp);
+			/* Nginx's proxy_module doesn't support HTTP 1.1 chunked
+			 * transfer encoding so we need to strip that header and
+			 * dechunk the data before passing to Nginx.
+			 */
+			chunked = detectChunkedTransferEncodingAndRemoveHeader(headerData);
+			
+			if (!log->isNull()) {
 				UPDATE_TRACE_POINT();
-				try {
-					string statusLine("HTTP/1.1 ");
-					statusLine.append(ex.getStatusLine());
-					UPDATE_TRACE_POINT();
-					writeExact(clientFd, statusLine);
-					UPDATE_TRACE_POINT();
-					writeExact(clientFd, ex.getBuffer());
-					if (!log->isNull()) {
-						string partialStatusLine = ex.getStatusLine();
-						partialStatusLine.erase(partialStatusLine.size() - 2, 2);
-						log->message("Status: " + partialStatusLine);
-					}
-					break;
-				} catch (const SystemException &e) {
-					if (e.code() == EPIPE) {
-						throw ClientDisconnectedException();
-					} else {
-						throw;
-					}
+				log->message("Status: " + status);
+			}
+			
+			UPDATE_TRACE_POINT();
+			
+			StaticString parts[6];
+			unsigned int nparts = 0;
+			parts[nparts++] = "HTTP/1.1 ";
+			parts[nparts++] = status;
+			if (chunked) {
+				P_TRACE(2, "Chunked response detected");
+				// Disable Nginx response buffering.
+				parts[nparts++] = "\r\nX-Accel-Buffering: no\r\n";
+			} else {
+				parts[nparts++] = "\r\n";
+			}
+			parts[nparts++] = headerData;
+			if (!chunked) {
+				// If the response doesn't have the chunked transfer encoding
+				// then forward the beginning of the response body as-in.
+				// Otherwise we have to filter it through the dechunker.
+				parts[nparts++] = nonHeaderData;
+			}
+			
+			try {
+				gatheredWrite(clientFd, parts, nparts);
+			} catch (const SystemException &e) {
+				if (e.code() == EPIPE) {
+					throw ClientDisconnectedException();
+				} else {
+					throw;
 				}
 			}
+			
+			if (chunked) {
+				dechunker.onData = forwardResponseChunk;
+				dechunker.userData = this;
+				dechunker.feed(nonHeaderData.data(), nonHeaderData.size());
+				if (dechunker.hasError()) {
+					P_ERROR("The backend process's chunked response is not valid (" <<
+						dechunker.getErrorMessage() << ")");
+					return;
+				}
+			}
+			
+		} else if (!headerBufferer.acceptingInput()) {
+			// Error: header too large.
+			assert(!eof);
+			assert(headerBufferer.hasError());
+			P_ERROR("The backend process's HTTP response header is too large. "
+				"For security reasons Phusion Passenger doesn't allow response "
+				"headers larger than 128 KB.");
+			return;
+			
+		} else {
+			// Error: incomplete header.
+			assert(eof);
+			return;
 		}
 		
+		/* Forward remaining response body. */
 		UPDATE_TRACE_POINT();
 		while (!eof) {
 			UPDATE_TRACE_POINT();
@@ -373,17 +702,35 @@ private:
 				throw SystemException("Cannot read response from backend process", errno);
 			} else {
 				UPDATE_TRACE_POINT();
-				try {
-					writeExact(clientFd, buf, size);
-				} catch (const SystemException &e) {
-					if (e.code() == EPIPE) {
-						throw ClientDisconnectedException();
-					} else {
-						throw;
+				if (chunked) {
+					dechunker.feed(buf, size);
+					if (dechunker.hasError()) {
+						P_ERROR("The backend process's chunked response is not valid (" <<
+							dechunker.getErrorMessage() << ")");
+						return;
 					}
+				} else {
+					forwardResponseChunk(buf, size, this);
 				}
 			}
 		}
+		
+		if (chunked && dechunker.acceptingInput()) {
+			P_WARN("The backend process's chunked response lacks a terminating chunk.");
+		}
+	}
+	
+	static void forwardResponseChunk(const char *data, size_t size, void *userData) {
+		Client *self = (Client *) userData;
+		try {
+			writeExact(self->currentClient, data, size);
+		} catch (const SystemException &e) {
+			if (e.code() == EPIPE) {
+				throw ClientDisconnectedException();
+			} else {
+				throw;
+			}
+		}
 	}
 	
 	/**
@@ -640,6 +987,10 @@ public:
 		this->defaultGroup = defaultGroup;
 		this->serverSocket = serverSocket;
 		this->analyticsLogger = logger;
+		
+		sbmh_init(&statusFinder.ctx, NULL, NULL, 0);
+		sbmh_init(&transferEncodingFinder.ctx, NULL, NULL, 0);
+		
 		thr = new oxt::thread(
 			boost::bind(&Client::threadMain, this),
 			"Client thread " + toString(number),
@@ -827,6 +1178,13 @@ public:
 		feedbackChannel     = MessageChannel(feedbackFd);
 		numberOfThreads     = maxPoolSize * 4;
 		
+		sbmh_init(NULL, &statusFinder_occ,
+			(const unsigned char *) "Status:",
+			strlen("Status:"));
+		sbmh_init(NULL, &transferEncodingFinder_occ,
+			(const unsigned char *) "Transfer-Encoding:",
+			strlen("Transfer-Encoding:"));
+		
 		UPDATE_TRACE_POINT();
 		requestSocketPassword = Base64::decode(options.get("request_socket_password"));
 		messageSocketPassword = Base64::decode(options.get("message_socket_password"));