passenger 5.0.8 → 5.0.9

data/ext/nginx/ContentHandler.c

@@ -140,12 +140,12 @@ map_uri_to_page_cache_file(ngx_http_request_t *r, ngx_str_t *public_dir,
 
     } else if (filename[filename_len - 1] == '/') {
         /* if the filename ends with '/' check for filename + "index.html". */
-        
+
         if (filename_len + sizeof("index.html") > page_cache_file->len) {
             /* Page cache filename doesn't fit in the buffer. */
             return 0;
         }
-        
+
         end = ngx_copy(page_cache_file->data, filename, filename_len);
         end = ngx_copy(end, "index.html", sizeof("index.html"));
     } else {
@@ -416,16 +416,27 @@ prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *
      * 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
+     *
+     * Here we check whether Nginx has rewritten the URI or not. If not,
+     * we can use the raw, unparsed URI as sent by the client.
      */
-    state->escaped_uri.len =
-        2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len, NGX_ESCAPE_URI)
-        + r->uri.len;
-    state->escaped_uri.data = ngx_pnalloc(r->pool, state->escaped_uri.len);
-    if (state->escaped_uri.data == NULL) {
-        return NGX_ERROR;
+    if (r->valid_unparsed_uri && r->main) {
+        state->escaped_uri = r->unparsed_uri;
+        const char *pos = memchr((const char *) r->unparsed_uri.data, '?', r->unparsed_uri.len);
+        if (pos != NULL) {
+            state->escaped_uri.len = pos - (const char *) r->unparsed_uri.data;
+        }
+    } else {
+        state->escaped_uri.len =
+            2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len, NGX_ESCAPE_URI)
+            + r->uri.len;
+        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);
     }
-    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

data/ext/nginx/ngx_http_passenger_module.c

@@ -302,6 +302,13 @@ start_watchdog(ngx_cycle_t *cycle) {
 
     if (passenger_main_conf.log_file.len > 0) {
         pp_variant_map_set_ngx_str(params, "log_file", &passenger_main_conf.log_file);
+    } else if (cycle->new_log.file == NULL) {
+        ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "Cannot initialize " PROGRAM_NAME
+            " because Nginx is not configured with an error log file."
+            " Please either configure Nginx with an error log file, or configure "
+            PROGRAM_NAME " with a `passenger_log_file`");
+        result = NGX_ERROR;
+        goto cleanup;
     } else if (cycle->new_log.file->name.len > 0) {
         pp_variant_map_set_ngx_str(params, "log_file", &cycle->new_log.file->name);
     } else if (cycle->log->file->name.len > 0) {

data/ext/oxt/implementation.cpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008-2014 Phusion
+ * Copyright (c) 2008-2015 Phusion
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -326,7 +326,8 @@ tracable_exception::what() const throw() {
 #endif /* OXT_BACKTRACE_IS_ENABLED */
 
 
-void initialize() {
+void
+initialize() {
 	global_context = new global_context_t();
 	init_thread_local_context_support();
 	// For some reason make_shared() crashes here when compiled with clang 3.2 on OS X.
@@ -342,6 +343,12 @@ void initialize() {
 	ctx->iterator--;
 }
 
+void shutdown() {
+	free_thread_local_context();
+	delete global_context;
+	global_context = NULL;
+}
+
 
 global_context_t::global_context_t()
 	: next_thread_number(2)

data/ext/oxt/initialize.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2012 Phusion
+ * Copyright (c) 2012-2015 Phusion
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -33,6 +33,10 @@ namespace oxt {
  * for that.
  */
 void initialize();
+/**
+ * Frees resources allocated by initialize().
+ */
+void shutdown();
 
 } // namespace oxt
 

data/lib/phusion_passenger.rb

@@ -30,10 +30,10 @@ module PhusionPassenger
 
   PACKAGE_NAME = 'passenger'
   # Run 'rake ext/common/Constants.h' after changing this number.
-  VERSION_STRING = '5.0.8'
+  VERSION_STRING = '5.0.9'
 
-  PREFERRED_NGINX_VERSION = '1.6.3'
-  NGINX_SHA256_CHECKSUM = '0a98e95b366e4d6042f331e1fa4d70e18fd1e49d8993e589008e70e742b7e757'
+  PREFERRED_NGINX_VERSION = '1.8.0'
+  NGINX_SHA256_CHECKSUM = '23cca1239990c818d8f6da118320c4979aadf5386deda691b1b7c2c96b9df3d5'
 
   PREFERRED_PCRE_VERSION  = '8.34'
   PCRE_SHA256_CHECKSUM = '1dd78994c81e44ac41cf30b2a21d4b4cc6d76ccde7fc6e77713ed51d7bddca47'

data/lib/phusion_passenger/admin_tools/instance.rb

@@ -59,28 +59,32 @@ module PhusionPassenger
 
       def locked?
         if defined?(File::LOCK_EX)
-          return !File.open("#{@path}/lock", "r") do |f|
-            f.flock(File::LOCK_EX | File::LOCK_NB)
+          begin
+            !File.open("#{@path}/lock", "r") do |f|
+              f.flock(File::LOCK_EX | File::LOCK_NB)
+            end
+          rescue Errno::ENOENT
+            false
           end
         else
           # Solaris :-(
           # Since using fcntl locks in Ruby is a huge pain,
           # we'll fallback to checking the watchdog PID.
-          return watchdog_alive?
+          watchdog_alive?
         end
       end
 
       def stale?
         stat = File.stat(@path)
         if stat.mtime < Time.now - STALE_TIMEOUT
-          return !locked?
+          !locked?
         else
-          return false
+          false
         end
       end
 
       def watchdog_alive?
-        return process_is_alive?(@watchdog_pid)
+        process_is_alive?(@watchdog_pid)
       end
 
       def http_request(socket_path, request)

data/lib/phusion_passenger/admin_tools/instance_registry.rb

@@ -102,8 +102,12 @@ module PhusionPassenger
 
       def cleanup(path)
         puts "*** Cleaning stale instance directory #{path}"
-        FileUtils.chmod_R(0700, path) rescue nil
-        FileUtils.remove_entry_secure(path)
+        begin
+          FileUtils.chmod_R(0700, path) rescue nil
+          FileUtils.remove_entry_secure(path)
+        rescue SystemCallError => e
+          puts "    Warning: #{e}"
+        end
       end
     end
 

data/lib/phusion_passenger/packaging.rb

@@ -100,10 +100,9 @@ module PhusionPassenger
       'ext/libev/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
       'ext/libev/{configure,configure.ac,depcomp,install-sh,ltmain.sh,missing,mkinstalldirs}',
       'ext/libev/{*.h,*.c}',
-      'ext/libeio/{LICENSE,Changes,README,Makefile.am,Makefile.in}',
-      'ext/libeio/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
-      'ext/libeio/{configure,configure.ac,install-sh,ltmain.sh,missing,mkinstalldirs}',
-      'ext/libeio/{*.h,*.c}',
+      'ext/libuv/**/*',
+      'ext/libuv/.gitignore',
+      'ext/libuv/m4/.gitignore',
       'ext/oxt/*.hpp',
       'ext/oxt/*.cpp',
       'ext/oxt/*.txt',

data/lib/phusion_passenger/platform_info.rb

@@ -1,6 +1,6 @@
 # encoding: binary
 #  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010-2014 Phusion
+#  Copyright (c) 2010-2015 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -366,6 +366,18 @@ module PhusionPassenger
       ["/opt/*/bin", "/opt/*/sbin", "/usr/local/*/bin", "/usr/local/*/sbin"].each do |glob|
         search_dirs.concat(Dir[glob])
       end
+
+      # Solaris systems may have Apache installations in
+      # /usr/apache2/2.2/bin/sparcv9/
+      Dir["/usr/apache2/*/bin"].each do |bindir|
+        search_dirs << bindir
+        Dir["#{bindir}/*"].each do |binsubdir|
+          if File.directory?(binsubdir)
+            search_dirs << binsubdir
+          end
+        end
+      end
+
       search_dirs.delete("")
       search_dirs.uniq!
 

data/lib/phusion_passenger/platform_info/apache.rb

@@ -649,14 +649,25 @@ module PhusionPassenger
     # Linker flags that are necessary for linking an Apache module.
     # Already includes APR and APU linker flags.
     def self.apache2_module_cxx_ldflags
+      flags = ""
+      if !apxs2.nil?
+        flags << `#{apxs2} -q LDFLAGS`.strip
+      end
+
+      # We must include the cxxflags in the linker flags. On some multilib
+      # Solaris systems, `apxs -q CFLAGS` outputs a flag that tells the compiler
+      # which architecture to compile against, while `apxs -q LDFLAGS` doesn't.
+      flags << " #{apache2_module_cxxflags} #{apr_cxx_ldflags} #{apu_cxx_ldflags}"
+
       if cxx_is_sun_studio?
-        flags = "-KPIC"
+        flags.gsub!("-fPIC", "-KPIC")
+        flags << " -KPIC" if !flags.include?("-KPIC")
       else
-        flags = "-fPIC"
+        flags << " -fPIC" if !flags.include?("-fPIC")
       end
-      flags << " #{apr_cxx_ldflags} #{apu_cxx_ldflags}"
+
       flags.strip!
-      return flags
+      flags
     end
     memoize :apache2_module_cxx_ldflags
 

data/lib/phusion_passenger/platform_info/apache_detector.rb

@@ -1,5 +1,5 @@
 #  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2013 Phusion
+#  Copyright (c) 2013-2015 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -107,6 +107,10 @@ module PhusionPassenger
         log "<banner>Looking for possible Apache installations...</banner>"
         apxses = PlatformInfo.find_all_commands("apxs2") +
           PlatformInfo.find_all_commands("apxs")
+        if !apxses.include?(PlatformInfo.apxs2)
+          PlatformInfo.send(:log, "Looking for #{PlatformInfo.apxs2}: found")
+          apxses << PlatformInfo.apxs2
+        end
         apxses = remove_symlink_duplications(apxses)
         log ""
         apxses.each do |apxs2|

data/lib/phusion_passenger/rack/thread_handler_extension.rb

@@ -39,13 +39,17 @@ module PhusionPassenger
       RACK_URL_SCHEME    = "rack.url_scheme"     # :nodoc:
       RACK_HIJACK_P      = "rack.hijack?"        # :nodoc:
       RACK_HIJACK        = "rack.hijack"         # :nodoc:
+      HTTP_VERSION       = "HTTP_VERSION"        # :nodoc:
+      HTTP_1_1           = "HTTP/1.1"            # :nodoc:
       SCRIPT_NAME        = "SCRIPT_NAME"         # :nodoc:
       REQUEST_METHOD = "REQUEST_METHOD"          # :nodoc:
       TRANSFER_ENCODING_HEADER  = "Transfer-Encoding"   # :nodoc:
       CONTENT_LENGTH_HEADER     = "Content-Length"      # :nodoc:
+      X_SENDFILE_HEADER         = "X-Sendfile"          # :nodoc:
+      X_ACCEL_REDIRECT_HEADER   = "X-Accel-Redirect"    # :nodoc:
       CONTENT_LENGTH_HEADER_AND_SEPARATOR      = "Content-Length: " # :nodoc
-      TRANSFER_ENCODING_HEADER_AND_VALUE_CRLF2 = "Transfer-Encoding: chunked\r\n\r\n" # :nodoc:
-      CONNECTION_CLOSE_CRLF     = "Connection: close\r\n"     # :nodoc:
+      TRANSFER_ENCODING_HEADER_AND_VALUE_CRLF  = "Transfer-Encoding: chunked\r\n" # :nodoc:
+      CONNECTION_CLOSE_CRLF2    = "Connection: close\r\n\r\n"     # :nodoc:
       HEAD           = "HEAD"   # :nodoc:
       HTTPS          = "HTTPS"  # :nodoc:
       HTTPS_DOWNCASE = "https"  # :nodoc:
@@ -80,6 +84,7 @@ module PhusionPassenger
               connection
             end
           end
+          env[HTTP_VERSION] = HTTP_1_1
 
           # Rails somehow modifies env['REQUEST_METHOD'], so we perform the comparison
           # before the Rack application object is called.
@@ -88,10 +93,7 @@ module PhusionPassenger
           begin
             status, headers, body = @app.call(env)
           rescue => e
-            disable_keep_alive
-            if should_reraise_app_error?(e, socket_wrapper)
-              raise e
-            elsif !should_swallow_app_error?(e, socket_wrapper)
+            if !should_swallow_app_error?(e, socket_wrapper)
               # It's a good idea to catch application exceptions here because
               # otherwise maliciously crafted responses can crash the app,
               # forcing it to be respawned, and thereby effectively DoSing it.
@@ -102,112 +104,206 @@ module PhusionPassenger
           end
 
           # Application requested a full socket hijack.
-          return true if env[RACK_HIJACK_IO]
+          if env[RACK_HIJACK_IO]
+            # Since the app hijacked the socket, we don't know what state we're
+            # in and we don't know whether we can recover from it, so we don't
+            # catch any exception here.
+            #
+            # The Rack specification doesn't specify whether the body should
+            # be closed when the socket is hijacked. As of February 2 2015,
+            # Puma and Thin close the body, while Unicorn does not.
+            # However, Rack::Lock and possibly many other middlewares count
+            # on the body being closed, as described here:
+            # https://github.com/ngauthier/tubesock/issues/10#issuecomment-72539461
+            # So we have chosen to close the body.
+            body.close if body && body.respond_to?(:close)
+            return true
+          end
+
+          # Application requested a partial socket hijack.
+          if hijack_callback = headers[RACK_HIJACK]
+            # We don't catch exceptions here. EPIPE is already handled
+            # by ThreadHandler's #accept_and_process_next_request.
+            # On any other exception, we don't know what state we're
+            # in and we don't know whether we can recover from it.
+            begin
+              headers_output = generate_headers_array(status, headers)
+              headers_output << CONNECTION_CLOSE_CRLF2
+              connection.writev(headers_output)
+              connection.flush
+              hijacked_socket = env[RACK_HIJACK].call
+              hijack_callback.call(hijacked_socket)
+              return true
+            ensure
+              body.close if body && body.respond_to?(:close)
+            end
+          end
 
           begin
             process_body(env, connection, socket_wrapper, status.to_i, is_head_request,
               headers, body)
-          rescue Exception => e
-            disable_keep_alive
-            raise
+          rescue => e
+            if !should_swallow_app_error?(e, socket_wrapper)
+              print_exception("Rack response body object", e)
+              PhusionPassenger.log_request_exception(env, e)
+            end
           ensure
-            body.close if body && body.respond_to?(:close)
+            begin
+              body.close if body && body.respond_to?(:close)
+            rescue => e
+              if !should_swallow_app_error?(e, socket_wrapper)
+                print_exception("Rack response body object's #close method", e)
+                PhusionPassenger.log_request_exception(env, e)
+              end
+            end
           end
+          false
         ensure
           rewindable_input.close
         end
       end
 
     private
-      # The code here is ugly, but it's necessary for performance.
       def process_body(env, connection, socket_wrapper, status, is_head_request, headers, body)
-        if hijack_callback = headers[RACK_HIJACK]
-          # Application requested a partial socket hijack.
-          body = nil
-          headers_output = generate_headers_array(status, headers)
-          headers_output << "Connection: close\r\n"
-          headers_output << CRLF
-          connection.writev(headers_output)
-          connection.flush
-          hijacked_socket = env[RACK_HIJACK].call
-          hijack_callback.call(hijacked_socket)
-          true
-        elsif body.is_a?(Array)
+        # Fix up incompliant body objects. Ensure that the body object
+        # can respond to #each.
+        output_body = should_output_body?(status, is_head_request)
+        if body.is_a?(String)
+          body = [body]
+        elsif body.nil?
+          body = []
+        elsif output_body && body.is_a?(Array)
           # The body may be an ActionController::StringCoercion::UglyBody
           # object instead of a real Array, even when #is_a? claims so.
-          # Call #to_a just to be sure.
+          # Call #to_a just to be sure that connection.writev() can
+          # accept the body object.
           body = body.to_a
-          output_body = should_output_body?(status, is_head_request)
-          headers_output = generate_headers_array(status, headers)
-          perform_keep_alive(env, headers_output)
-          if output_body && should_add_message_length_header?(status, headers)
-            body_size = 0
-            body.each { |part| body_size += bytesize(part.to_s) }
-            headers_output << CONTENT_LENGTH_HEADER_AND_SEPARATOR
-            headers_output << body_size.to_s
-            headers_output << CRLF
+        end
+
+        # Generate preliminary headers and determine whether we need to output a body.
+        headers_output = generate_headers_array(status, headers)
+
+
+        # Determine how big the body is, determine whether we should try to keep-alive
+        # the connection, and fix up the headers according to the situation.
+        #
+        # It may not be possible to determine the body's size (e.g. because it's streamed
+        # through #each). In that case we'll want to output the body with a chunked transfer
+        # encoding. But it matters whether the app has already chunked the body or not.
+        #
+        # Note that if the Rack response header contains "Transfer-Encoding: chunked",
+        # then we assume that the Rack body is already in chunked form. This is the way
+        # Rails streaming and Rack::Chunked::Body behave.
+        # The only gem that doesn't behave this way is JRuby-Rack (see
+        # https://blog.engineyard.com/2011/taking-stock-jruby-web-servers), but I'm not
+        # aware of anybody using JRuby-Rack these days.
+        #
+        # We only try to keep-alive the connection if we are able to determine ahead of
+        # time that the body we write out is guaranteed to match what the headers say.
+        # Otherwise we disable keep-alive to prevent the app from being able to mess
+        # up the keep-alive connection.
+        if header = headers[CONTENT_LENGTH_HEADER]
+          # Easiest case: app has a Content-Length header. The headers
+          # need no fixing.
+          message_length_type = :content_length
+          content_length = header.to_i
+          if headers.has_key?(TRANSFER_ENCODING_HEADER)
+            # Disallowed by the HTTP spec
+            raise "Response object may not contain both Content-Length and Transfer-Encoding"
           end
-          headers_output << CRLF
           if output_body
-            connection.writev2(headers_output, body)
-          else
-            connection.writev(headers_output)
+            if !body.is_a?(Array) || headers.has_key?(X_SENDFILE_HEADER) ||
+               headers.has_key?(X_ACCEL_REDIRECT_HEADER)
+              # If X-Sendfile or X-Accel-Redirect is set, don't check the
+              # body size. PassengerAgent's RequestHandler will ignore the
+              # body anyway. See
+              # ServerKit::HttpHeaderParser::processParseResult(const HttpParseResponse &)
+              @can_keepalive = false
+            else
+              body_size = 0
+              body.each { |part| body_size += bytesize(part) }
+              if body_size != content_length
+                raise "Response body size doesn't match Content-Length header: #{body_size} vs #{content_length}"
+              end
+            end
           end
-          false
-        elsif body.is_a?(String)
-          output_body = should_output_body?(status, is_head_request)
-          headers_output = generate_headers_array(status, headers)
-          perform_keep_alive(env, headers_output)
-          if output_body && should_add_message_length_header?(status, headers)
+        elsif headers.has_key?(TRANSFER_ENCODING_HEADER)
+          # App has a Transfer-Encoding header. We assume that the app
+          # has already chunked the body. The headers need no fixing.
+          message_length_type = :chunked_by_app
+          if output_body
+            # We have no way to determine whether the body was correct (save for
+            # parsing the chunking headers), so we don't keep-alive the connection
+            # just to be safe.
+            @can_keepalive = false
+          end
+          if headers.has_key?(CONTENT_LENGTH_HEADER)
+            # Disallowed by the HTTP spec
+            raise "Response object may not contain both Content-Length and Transfer-Encoding"
+          end
+        else
+          # The app has set neither the Content-Length nor the Transfer-Encoding
+          # header. This means we'll have to add one of those headers. We know exactly how
+          # big our body will be, so we can keep-alive the connection.
+          if body.is_a?(Array)
+            message_length_type = :content_length
+            content_length = 0
+            body.each { |part| content_length += bytesize(part.to_s) }
+
             headers_output << CONTENT_LENGTH_HEADER_AND_SEPARATOR
-            headers_output << bytesize(body).to_s
+            headers_output << content_length.to_s
             headers_output << CRLF
+          else
+            message_length_type = :needs_chunking
+            headers_output << TRANSFER_ENCODING_HEADER_AND_VALUE_CRLF
           end
+        end
+
+        # Finalize headers data.
+        if @can_keepalive
           headers_output << CRLF
-          if output_body
-            headers_output << body
-          end
-          connection.writev(headers_output)
-          false
         else
-          output_body = should_output_body?(status, is_head_request)
-          headers_output = generate_headers_array(status, headers)
-          perform_keep_alive(env, headers_output)
-          chunk = output_body && should_add_message_length_header?(status, headers)
-          if chunk
-            headers_output << TRANSFER_ENCODING_HEADER_AND_VALUE_CRLF2
+          headers_output << CONNECTION_CLOSE_CRLF2
+        end
+
+
+        # If this is a request without body, write out headers without body.
+        if !output_body
+          connection.writev(headers_output)
+          signal_keep_alive_allowed!
+          return
+        end
+
+        # Otherwise, write out headers and body, then verify at the end whether what
+        # we wrote is matches the message length. Only keep-alive connection if it
+        # is the case.
+        case message_length_type
+        when :content_length
+          if body.is_a?(Array)
+            connection.writev2(headers_output, body)
           else
-            headers_output << CRLF
+            connection.writev(headers_output)
+            body.each do |part|
+              connection.write(part.to_s)
+            end
           end
+        when :chunked_by_app
           connection.writev(headers_output)
-          if output_body && body
-            begin
-              if chunk
-                body.each do |part|
-                  size = bytesize(part)
-                  if size != 0
-                    connection.writev(chunk_data(part, size))
-                  end
-                end
-                connection.write(TERMINATION_CHUNK)
-              else
-                body.each do |s|
-                  connection.write(s)
-                end
-              end
-            rescue => e
-              disable_keep_alive
-              if should_reraise_app_error?(e, socket_wrapper)
-                raise e
-              elsif !should_swallow_app_error?(e, socket_wrapper)
-                # Body objects can raise exceptions in #each.
-                print_exception("Rack body object #each method", e)
-              end
-              false
+          body.each do |part|
+            connection.write(part.to_s)
+          end
+        when :needs_chunking
+          connection.writev(headers_output)
+          body.each do |part|
+            size = bytesize(part.to_s)
+            if size != 0
+              connection.writev(chunk_data(part.to_s, size))
             end
           end
-          false
+          connection.write(TERMINATION_CHUNK)
         end
+
+        signal_keep_alive_allowed!
       end
 
       def generate_headers_array(status, headers)
@@ -233,33 +329,22 @@ module PhusionPassenger
         return result
       end
 
-      def perform_keep_alive(env, headers)
-        if @can_keepalive
-          @keepalive_performed = true
-        else
-          headers << CONNECTION_CLOSE_CRLF
-        end
-      end
-
-      def disable_keep_alive
-        @keepalive_performed = false
-      end
-
       def should_output_body?(status, is_head_request)
         return (status < 100 ||
           (status >= 200 && status != 204 && status != 205 && status != 304)) &&
           !is_head_request
       end
 
-      def should_add_message_length_header?(status, headers)
-        return !headers.has_key?(TRANSFER_ENCODING_HEADER) &&
-          !headers.has_key?(CONTENT_LENGTH_HEADER)
-      end
-
       def chunk_data(data, size)
         [size.to_s(16), CRLF, data, CRLF]
       end
 
+      # Called when body is written out successfully. Indicates that we should
+      # keep-alive the connection if we can.
+      def signal_keep_alive_allowed!
+        @keepalive_performed = @can_keepalive
+      end
+
       if "".respond_to?(:bytesize)
         def bytesize(str)
           str.bytesize