rubysl-net-http 1.0.1 → 2.0.4

data/lib/net/http/responses.rb

@@ -0,0 +1,268 @@
+# :stopdoc:
+class Net::HTTPUnknownResponse < Net::HTTPResponse
+  HAS_BODY = true
+  EXCEPTION_TYPE = Net::HTTPError
+end
+class Net::HTTPInformation < Net::HTTPResponse           # 1xx
+  HAS_BODY = false
+  EXCEPTION_TYPE = Net::HTTPError
+end
+class Net::HTTPSuccess < Net::HTTPResponse               # 2xx
+  HAS_BODY = true
+  EXCEPTION_TYPE = Net::HTTPError
+end
+class Net::HTTPRedirection < Net::HTTPResponse           # 3xx
+  HAS_BODY = true
+  EXCEPTION_TYPE = Net::HTTPRetriableError
+end
+class Net::HTTPClientError < Net::HTTPResponse           # 4xx
+  HAS_BODY = true
+  EXCEPTION_TYPE = Net::HTTPServerException   # for backward compatibility
+end
+class Net::HTTPServerError < Net::HTTPResponse           # 5xx
+  HAS_BODY = true
+  EXCEPTION_TYPE = Net::HTTPFatalError    # for backward compatibility
+end
+
+class Net::HTTPContinue < Net::HTTPInformation           # 100
+  HAS_BODY = false
+end
+class Net::HTTPSwitchProtocol < Net::HTTPInformation     # 101
+  HAS_BODY = false
+end
+# 102 - RFC 2518; removed in RFC 4918
+
+class Net::HTTPOK < Net::HTTPSuccess                            # 200
+  HAS_BODY = true
+end
+class Net::HTTPCreated < Net::HTTPSuccess                       # 201
+  HAS_BODY = true
+end
+class Net::HTTPAccepted < Net::HTTPSuccess                      # 202
+  HAS_BODY = true
+end
+class Net::HTTPNonAuthoritativeInformation < Net::HTTPSuccess   # 203
+  HAS_BODY = true
+end
+class Net::HTTPNoContent < Net::HTTPSuccess                     # 204
+  HAS_BODY = false
+end
+class Net::HTTPResetContent < Net::HTTPSuccess                  # 205
+  HAS_BODY = false
+end
+class Net::HTTPPartialContent < Net::HTTPSuccess                # 206
+  HAS_BODY = true
+end
+class Net::HTTPMultiStatus < Net::HTTPSuccess                   # 207 - RFC 4918
+  HAS_BODY = true
+end
+# 208 Already Reported - RFC 5842; experimental
+# 226 IM Used - RFC 3229; no famous implementation known
+
+class Net::HTTPMultipleChoices < Net::HTTPRedirection    # 300
+  HAS_BODY = true
+end
+Net::HTTPMultipleChoice = Net::HTTPMultipleChoices
+class Net::HTTPMovedPermanently < Net::HTTPRedirection   # 301
+  HAS_BODY = true
+end
+class Net::HTTPFound < Net::HTTPRedirection              # 302
+  HAS_BODY = true
+end
+Net::HTTPMovedTemporarily = Net::HTTPFound
+class Net::HTTPSeeOther < Net::HTTPRedirection           # 303
+  HAS_BODY = true
+end
+class Net::HTTPNotModified < Net::HTTPRedirection        # 304
+  HAS_BODY = false
+end
+class Net::HTTPUseProxy < Net::HTTPRedirection           # 305
+  HAS_BODY = false
+end
+# 306 Switch Proxy - no longer unused
+class Net::HTTPTemporaryRedirect < Net::HTTPRedirection  # 307
+  HAS_BODY = true
+end
+# 308 Permanent Redirect - in draft
+
+class Net::HTTPBadRequest < Net::HTTPClientError                    # 400
+  HAS_BODY = true
+end
+class Net::HTTPUnauthorized < Net::HTTPClientError                  # 401
+  HAS_BODY = true
+end
+class Net::HTTPPaymentRequired < Net::HTTPClientError               # 402
+  HAS_BODY = true
+end
+class Net::HTTPForbidden < Net::HTTPClientError                     # 403
+  HAS_BODY = true
+end
+class Net::HTTPNotFound < Net::HTTPClientError                      # 404
+  HAS_BODY = true
+end
+class Net::HTTPMethodNotAllowed < Net::HTTPClientError              # 405
+  HAS_BODY = true
+end
+class Net::HTTPNotAcceptable < Net::HTTPClientError                 # 406
+  HAS_BODY = true
+end
+class Net::HTTPProxyAuthenticationRequired < Net::HTTPClientError   # 407
+  HAS_BODY = true
+end
+class Net::HTTPRequestTimeOut < Net::HTTPClientError                # 408
+  HAS_BODY = true
+end
+class Net::HTTPConflict < Net::HTTPClientError                      # 409
+  HAS_BODY = true
+end
+class Net::HTTPGone < Net::HTTPClientError                          # 410
+  HAS_BODY = true
+end
+class Net::HTTPLengthRequired < Net::HTTPClientError                # 411
+  HAS_BODY = true
+end
+class Net::HTTPPreconditionFailed < Net::HTTPClientError            # 412
+  HAS_BODY = true
+end
+class Net::HTTPRequestEntityTooLarge < Net::HTTPClientError         # 413
+  HAS_BODY = true
+end
+class Net::HTTPRequestURITooLong < Net::HTTPClientError             # 414
+  HAS_BODY = true
+end
+Net::HTTPRequestURITooLarge = Net::HTTPRequestURITooLong
+class Net::HTTPUnsupportedMediaType < Net::HTTPClientError          # 415
+  HAS_BODY = true
+end
+class Net::HTTPRequestedRangeNotSatisfiable < Net::HTTPClientError  # 416
+  HAS_BODY = true
+end
+class Net::HTTPExpectationFailed < Net::HTTPClientError             # 417
+  HAS_BODY = true
+end
+# 418 I'm a teapot - RFC 2324; a joke RFC
+# 420 Enhance Your Calm - Twitter
+class Net::HTTPUnprocessableEntity < Net::HTTPClientError           # 422 - RFC 4918
+  HAS_BODY = true
+end
+class Net::HTTPLocked < Net::HTTPClientError                        # 423 - RFC 4918
+  HAS_BODY = true
+end
+class Net::HTTPFailedDependency < Net::HTTPClientError              # 424 - RFC 4918
+  HAS_BODY = true
+end
+# 425 Unordered Collection - existed only in draft
+class Net::HTTPUpgradeRequired < Net::HTTPClientError               # 426 - RFC 2817
+  HAS_BODY = true
+end
+class Net::HTTPPreconditionRequired < Net::HTTPClientError          # 428 - RFC 6585
+  HAS_BODY = true
+end
+class Net::HTTPTooManyRequests < Net::HTTPClientError               # 429 - RFC 6585
+  HAS_BODY = true
+end
+class Net::HTTPRequestHeaderFieldsTooLarge < Net::HTTPClientError   # 431 - RFC 6585
+  HAS_BODY = true
+end
+# 444 No Response - Nginx
+# 449 Retry With - Microsoft
+# 450 Blocked by Windows Parental Controls - Microsoft
+# 499 Client Closed Request - Nginx
+
+class Net::HTTPInternalServerError < Net::HTTPServerError           # 500
+  HAS_BODY = true
+end
+class Net::HTTPNotImplemented < Net::HTTPServerError                # 501
+  HAS_BODY = true
+end
+class Net::HTTPBadGateway < Net::HTTPServerError                    # 502
+  HAS_BODY = true
+end
+class Net::HTTPServiceUnavailable < Net::HTTPServerError            # 503
+  HAS_BODY = true
+end
+class Net::HTTPGatewayTimeOut < Net::HTTPServerError                # 504
+  HAS_BODY = true
+end
+class Net::HTTPVersionNotSupported < Net::HTTPServerError           # 505
+  HAS_BODY = true
+end
+# 506 Variant Also Negotiates - RFC 2295; experimental
+class Net::HTTPInsufficientStorage < Net::HTTPServerError           # 507 - RFC 4918
+  HAS_BODY = true
+end
+# 508 Loop Detected - RFC 5842; experimental
+# 509 Bandwidth Limit Exceeded - Apache bw/limited extension
+# 510 Not Extended - RFC 2774; experimental
+class Net::HTTPNetworkAuthenticationRequired < Net::HTTPServerError # 511 - RFC 6585
+  HAS_BODY = true
+end
+
+class Net::HTTPResponse
+  CODE_CLASS_TO_OBJ = {
+    '1' => Net::HTTPInformation,
+    '2' => Net::HTTPSuccess,
+    '3' => Net::HTTPRedirection,
+    '4' => Net::HTTPClientError,
+    '5' => Net::HTTPServerError
+  }
+  CODE_TO_OBJ = {
+    '100' => Net::HTTPContinue,
+    '101' => Net::HTTPSwitchProtocol,
+
+    '200' => Net::HTTPOK,
+    '201' => Net::HTTPCreated,
+    '202' => Net::HTTPAccepted,
+    '203' => Net::HTTPNonAuthoritativeInformation,
+    '204' => Net::HTTPNoContent,
+    '205' => Net::HTTPResetContent,
+    '206' => Net::HTTPPartialContent,
+    '207' => Net::HTTPMultiStatus,
+
+    '300' => Net::HTTPMultipleChoices,
+    '301' => Net::HTTPMovedPermanently,
+    '302' => Net::HTTPFound,
+    '303' => Net::HTTPSeeOther,
+    '304' => Net::HTTPNotModified,
+    '305' => Net::HTTPUseProxy,
+    '307' => Net::HTTPTemporaryRedirect,
+
+    '400' => Net::HTTPBadRequest,
+    '401' => Net::HTTPUnauthorized,
+    '402' => Net::HTTPPaymentRequired,
+    '403' => Net::HTTPForbidden,
+    '404' => Net::HTTPNotFound,
+    '405' => Net::HTTPMethodNotAllowed,
+    '406' => Net::HTTPNotAcceptable,
+    '407' => Net::HTTPProxyAuthenticationRequired,
+    '408' => Net::HTTPRequestTimeOut,
+    '409' => Net::HTTPConflict,
+    '410' => Net::HTTPGone,
+    '411' => Net::HTTPLengthRequired,
+    '412' => Net::HTTPPreconditionFailed,
+    '413' => Net::HTTPRequestEntityTooLarge,
+    '414' => Net::HTTPRequestURITooLong,
+    '415' => Net::HTTPUnsupportedMediaType,
+    '416' => Net::HTTPRequestedRangeNotSatisfiable,
+    '417' => Net::HTTPExpectationFailed,
+    '422' => Net::HTTPUnprocessableEntity,
+    '423' => Net::HTTPLocked,
+    '424' => Net::HTTPFailedDependency,
+    '426' => Net::HTTPUpgradeRequired,
+    '428' => Net::HTTPPreconditionRequired,
+    '429' => Net::HTTPTooManyRequests,
+    '431' => Net::HTTPRequestHeaderFieldsTooLarge,
+
+    '500' => Net::HTTPInternalServerError,
+    '501' => Net::HTTPNotImplemented,
+    '502' => Net::HTTPBadGateway,
+    '503' => Net::HTTPServiceUnavailable,
+    '504' => Net::HTTPGatewayTimeOut,
+    '505' => Net::HTTPVersionNotSupported,
+    '507' => Net::HTTPInsufficientStorage,
+    '511' => Net::HTTPNetworkAuthenticationRequired,
+  }
+end
+
+# :startdoc:
+

data/lib/rubysl/net/http/http.rb

@@ -1,8 +1,8 @@
 #
 # = net/http.rb
 #
-# Copyright (c) 1999-2006 Yukihiro Matsumoto
-# Copyright (c) 1999-2006 Minero Aoki
+# Copyright (c) 1999-2007 Yukihiro Matsumoto
+# Copyright (c) 1999-2007 Minero Aoki
 # Copyright (c) 2001 GOTOU Yuuzou
 #
 # Written and maintained by Minero Aoki <aamine@loveruby.net>.
@@ -18,299 +18,397 @@
 #
 # See Net::HTTP for an overview and examples.
 #
-# NOTE: You can find Japanese version of this document here:
-# http://www.ruby-lang.org/ja/man/?cmd=view;name=net%2Fhttp.rb
-#
-#--
-# $Id$
-#++
 
 require 'net/protocol'
 require 'uri'
 
 module Net   #:nodoc:
+  autoload :OpenSSL, 'openssl'
 
   # :stopdoc:
   class HTTPBadResponse < StandardError; end
   class HTTPHeaderSyntaxError < StandardError; end
   # :startdoc:
 
-  # == What Is This Library?
+  # == An HTTP client API for Ruby.
   #
-  # This library provides your program functions to access WWW
-  # documents via HTTP, Hyper Text Transfer Protocol version 1.1.
-  # For details of HTTP, refer [RFC2616]
-  # (http://www.ietf.org/rfc/rfc2616.txt).
+  # Net::HTTP provides a rich library which can be used to build HTTP
+  # user-agents.  For more details about HTTP see
+  # [RFC2616](http://www.ietf.org/rfc/rfc2616.txt)
   #
-  # == Examples
+  # Net::HTTP is designed to work closely with URI.  URI::HTTP#host,
+  # URI::HTTP#port and URI::HTTP#request_uri are designed to work with
+  # Net::HTTP.
   #
-  # === Getting Document From WWW Server
+  # If you are only performing a few GET requests you should try OpenURI.
   #
-  # Example #1: Simple GET+print
+  # == Simple Examples
   #
-  #     require 'net/http'
-  #     Net::HTTP.get_print 'www.example.com', '/index.html'
+  # All examples assume you have loaded Net::HTTP with:
   #
-  # Example #2: Simple GET+print by URL
+  #   require 'net/http'
   #
-  #     require 'net/http'
-  #     require 'uri'
-  #     Net::HTTP.get_print URI.parse('http://www.example.com/index.html')
+  # This will also require 'uri' so you don't need to require it separately.
   #
-  # Example #3: More generic GET+print
+  # The Net::HTTP methods in the following section do not persist
+  # connections.  They are not recommended if you are performing many HTTP
+  # requests.
   #
-  #     require 'net/http'
-  #     require 'uri'
+  # === GET
   #
-  #     url = URI.parse('http://www.example.com/index.html')
-  #     res = Net::HTTP.start(url.host, url.port) {|http|
-  #       http.get('/index.html')
-  #     }
-  #     puts res.body
+  #   Net::HTTP.get('example.com', '/index.html') # => String
   #
-  # Example #4: More generic GET+print
+  # === GET by URI
   #
-  #     require 'net/http'
+  #   uri = URI('http://example.com/index.html?count=10')
+  #   Net::HTTP.get(uri) # => String
   #
-  #     url = URI.parse('http://www.example.com/index.html')
-  #     req = Net::HTTP::Get.new(url.path)
-  #     res = Net::HTTP.start(url.host, url.port) {|http|
-  #       http.request(req)
-  #     }
-  #     puts res.body
+  # === GET with Dynamic Parameters
   #
-  # === Posting Form Data
+  #   uri = URI('http://example.com/index.html')
+  #   params = { :limit => 10, :page => 3 }
+  #   uri.query = URI.encode_www_form(params)
   #
-  #     require 'net/http'
-  #     require 'uri'
+  #   res = Net::HTTP.get_response(uri)
+  #   puts res.body if res.is_a?(Net::HTTPSuccess)
   #
-  #     #1: Simple POST
-  #     res = Net::HTTP.post_form(URI.parse('http://www.example.com/search.cgi'),
-  #                               {'q'=>'ruby', 'max'=>'50'})
-  #     puts res.body
+  # === POST
   #
-  #     #2: POST with basic authentication
-  #     res = Net::HTTP.post_form(URI.parse('http://jack:pass@www.example.com/todo.cgi'),
-  #                                         {'from'=>'2005-01-01', 'to'=>'2005-03-31'})
-  #     puts res.body
+  #   uri = URI('http://www.example.com/search.cgi')
+  #   res = Net::HTTP.post_form(uri, 'q' => 'ruby', 'max' => '50')
+  #   puts res.body
   #
-  #     #3: Detailed control
-  #     url = URI.parse('http://www.example.com/todo.cgi')
-  #     req = Net::HTTP::Post.new(url.path)
-  #     req.basic_auth 'jack', 'pass'
-  #     req.set_form_data({'from'=>'2005-01-01', 'to'=>'2005-03-31'}, ';')
-  #     res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
-  #     case res
-  #     when Net::HTTPSuccess, Net::HTTPRedirection
-  #       # OK
-  #     else
-  #       res.error!
-  #     end
+  # === POST with Multiple Values
+  #
+  #   uri = URI('http://www.example.com/search.cgi')
+  #   res = Net::HTTP.post_form(uri, 'q' => ['ruby', 'perl'], 'max' => '50')
+  #   puts res.body
   #
-  # === Accessing via Proxy
+  # == How to use Net::HTTP
   #
-  # Net::HTTP.Proxy creates http proxy class. It has same
-  # methods of Net::HTTP but its instances always connect to
-  # proxy, instead of given host.
+  # The following example code can be used as the basis of a HTTP user-agent
+  # which can perform a variety of request types using persistent
+  # connections.
   #
-  #     require 'net/http'
+  #   uri = URI('http://example.com/some_path?query=string')
   #
-  #     proxy_addr = 'your.proxy.host'
-  #     proxy_port = 8080
-  #             :
-  #     Net::HTTP::Proxy(proxy_addr, proxy_port).start('www.example.com') {|http|
-  #       # always connect to your.proxy.addr:8080
-  #             :
-  #     }
+  #   Net::HTTP.start(uri.host, uri.port) do |http|
+  #     request = Net::HTTP::Get.new uri
   #
-  # Since Net::HTTP.Proxy returns Net::HTTP itself when proxy_addr is nil,
-  # there's no need to change code if there's proxy or not.
+  #     response = http.request request # Net::HTTPResponse object
+  #   end
   #
-  # There are two additional parameters in Net::HTTP.Proxy which allow to
-  # specify proxy user name and password:
+  # Net::HTTP::start immediately creates a connection to an HTTP server which
+  # is kept open for the duration of the block.  The connection will remain
+  # open for multiple requests in the block if the server indicates it
+  # supports persistent connections.
   #
-  #     Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user = nil, proxy_pass = nil)
+  # The request types Net::HTTP supports are listed below in the section "HTTP
+  # Request Classes".
   #
-  # You may use them to work with authorization-enabled proxies:
+  # If you wish to re-use a connection across multiple HTTP requests without
+  # automatically closing it you can use ::new instead of ::start.  #request
+  # will automatically open a connection to the server if one is not currently
+  # open.  You can manually close the connection with #finish.
   #
-  #     require 'net/http'
-  #     require 'uri'
+  # For all the Net::HTTP request objects and shortcut request methods you may
+  # supply either a String for the request path or a URI from which Net::HTTP
+  # will extract the request path.
   #
-  #     proxy_host = 'your.proxy.host'
-  #     proxy_port = 8080
-  #     uri = URI.parse(ENV['http_proxy'])
-  #     proxy_user, proxy_pass = uri.userinfo.split(/:/) if uri.userinfo
-  #     Net::HTTP::Proxy(proxy_host, proxy_port,
-  #                      proxy_user, proxy_pass).start('www.example.com') {|http|
-  #       # always connect to your.proxy.addr:8080 using specified username and password
-  #             :
-  #     }
+  # === Response Data
   #
-  # Note that net/http never rely on HTTP_PROXY environment variable.
-  # If you want to use proxy, set it explicitly.
+  #   uri = URI('http://example.com/index.html')
+  #   res = Net::HTTP.get_response(uri)
+  #
+  #   # Headers
+  #   res['Set-Cookie']            # => String
+  #   res.get_fields('set-cookie') # => Array
+  #   res.to_hash['set-cookie']    # => Array
+  #   puts "Headers: #{res.to_hash.inspect}"
+  #
+  #   # Status
+  #   puts res.code       # => '200'
+  #   puts res.message    # => 'OK'
+  #   puts res.class.name # => 'HTTPOK'
+  #
+  #   # Body
+  #   puts res.body if res.response_body_permitted?
   #
   # === Following Redirection
   #
-  #     require 'net/http'
-  #     require 'uri'
+  # Each Net::HTTPResponse object belongs to a class for its response code.
   #
-  #     def fetch(uri_str, limit = 10)
-  #       # You should choose better exception.
-  #       raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+  # For example, all 2XX responses are instances of a Net::HTTPSuccess
+  # subclass, a 3XX response is an instance of a Net::HTTPRedirection
+  # subclass and a 200 response is an instance of the Net::HTTPOK class.  For
+  # details of response classes, see the section "HTTP Response Classes"
+  # below.
   #
-  #       response = Net::HTTP.get_response(URI.parse(uri_str))
-  #       case response
-  #       when Net::HTTPSuccess     then response
-  #       when Net::HTTPRedirection then fetch(response['location'], limit - 1)
-  #       else
-  #         response.error!
-  #       end
+  # Using a case statement you can handle various types of responses properly:
+  #
+  #   def fetch(uri_str, limit = 10)
+  #     # You should choose a better exception.
+  #     raise ArgumentError, 'too many HTTP redirects' if limit == 0
+  #
+  #     response = Net::HTTP.get_response(URI(uri_str))
+  #
+  #     case response
+  #     when Net::HTTPSuccess then
+  #       response
+  #     when Net::HTTPRedirection then
+  #       location = response['location']
+  #       warn "redirected to #{location}"
+  #       fetch(location, limit - 1)
+  #     else
+  #       response.value
   #     end
+  #   end
+  #
+  #   print fetch('http://www.ruby-lang.org')
+  #
+  # === POST
+  #
+  # A POST can be made using the Net::HTTP::Post request class.  This example
+  # creates a urlencoded POST body:
+  #
+  #   uri = URI('http://www.example.com/todo.cgi')
+  #   req = Net::HTTP::Post.new(uri)
+  #   req.set_form_data('from' => '2005-01-01', 'to' => '2005-03-31')
   #
-  #     print fetch('http://www.ruby-lang.org')
+  #   res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+  #     http.request(req)
+  #   end
   #
-  # Net::HTTPSuccess and Net::HTTPRedirection is a HTTPResponse class.
-  # All HTTPResponse objects belong to its own response class which
-  # indicate HTTP result status. For details of response classes,
-  # see section "HTTP Response Classes".
+  #   case res
+  #   when Net::HTTPSuccess, Net::HTTPRedirection
+  #     # OK
+  #   else
+  #     res.value
+  #   end
+  #
+  # At this time Net::HTTP does not support multipart/form-data.  To send
+  # multipart/form-data use Net::HTTPRequest#body= and
+  # Net::HTTPRequest#content_type=:
+  #
+  #   req = Net::HTTP::Post.new(uri)
+  #   req.body = multipart_data
+  #   req.content_type = 'multipart/form-data'
+  #
+  # Other requests that can contain a body such as PUT can be created in the
+  # same way using the corresponding request class (Net::HTTP::Put).
+  #
+  # === Setting Headers
+  #
+  # The following example performs a conditional GET using the
+  # If-Modified-Since header.  If the files has not been modified since the
+  # time in the header a Not Modified response will be returned.  See RFC 2616
+  # section 9.3 for further details.
+  #
+  #   uri = URI('http://example.com/cached_response')
+  #   file = File.stat 'cached_response'
+  #
+  #   req = Net::HTTP::Get.new(uri)
+  #   req['If-Modified-Since'] = file.mtime.rfc2822
+  #
+  #   res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+  #     http.request(req)
+  #   }
+  #
+  #   open 'cached_response', 'w' do |io|
+  #     io.write res.body
+  #   end if res.is_a?(Net::HTTPSuccess)
   #
   # === Basic Authentication
   #
-  #     require 'net/http'
-  #
-  #     Net::HTTP.start('www.example.com') {|http|
-  #       req = Net::HTTP::Get.new('/secret-page.html')
-  #       req.basic_auth 'account', 'password'
-  #       response = http.request(req)
-  #       print response.body
-  #     }
-  #
-  # === HTTP Request Classes
-  #
-  # Here is HTTP request class hierarchy.
-  #
-  #   Net::HTTPRequest
-  #       Net::HTTP::Get
-  #       Net::HTTP::Head
-  #       Net::HTTP::Post
-  #       Net::HTTP::Put
-  #       Net::HTTP::Proppatch
-  #       Net::HTTP::Lock
-  #       Net::HTTP::Unlock
-  #       Net::HTTP::Options
-  #       Net::HTTP::Propfind
-  #       Net::HTTP::Delete
-  #       Net::HTTP::Move
-  #       Net::HTTP::Copy
-  #       Net::HTTP::Mkcol
-  #       Net::HTTP::Trace
-  #
-  # === HTTP Response Classes
-  #
-  # Here is HTTP response class hierarchy.
-  # All classes are defined in Net module.
-  #
-  #   HTTPResponse
-  #       HTTPUnknownResponse
-  #       HTTPInformation                    # 1xx
-  #           HTTPContinue                       # 100
-  #           HTTPSwitchProtocl                  # 101
-  #       HTTPSuccess                        # 2xx
-  #           HTTPOK                             # 200
-  #           HTTPCreated                        # 201
-  #           HTTPAccepted                       # 202
-  #           HTTPNonAuthoritativeInformation    # 203
-  #           HTTPNoContent                      # 204
-  #           HTTPResetContent                   # 205
-  #           HTTPPartialContent                 # 206
-  #       HTTPRedirection                    # 3xx
-  #           HTTPMultipleChoice                 # 300
-  #           HTTPMovedPermanently               # 301
-  #           HTTPFound                          # 302
-  #           HTTPSeeOther                       # 303
-  #           HTTPNotModified                    # 304
-  #           HTTPUseProxy                       # 305
-  #           HTTPTemporaryRedirect              # 307
-  #       HTTPClientError                    # 4xx
-  #           HTTPBadRequest                     # 400
-  #           HTTPUnauthorized                   # 401
-  #           HTTPPaymentRequired                # 402
-  #           HTTPForbidden                      # 403
-  #           HTTPNotFound                       # 404
-  #           HTTPMethodNotAllowed               # 405
-  #           HTTPNotAcceptable                  # 406
-  #           HTTPProxyAuthenticationRequired    # 407
-  #           HTTPRequestTimeOut                 # 408
-  #           HTTPConflict                       # 409
-  #           HTTPGone                           # 410
-  #           HTTPLengthRequired                 # 411
-  #           HTTPPreconditionFailed             # 412
-  #           HTTPRequestEntityTooLarge          # 413
-  #           HTTPRequestURITooLong              # 414
-  #           HTTPUnsupportedMediaType           # 415
-  #           HTTPRequestedRangeNotSatisfiable   # 416
-  #           HTTPExpectationFailed              # 417
-  #       HTTPServerError                    # 5xx
-  #           HTTPInternalServerError            # 500
-  #           HTTPNotImplemented                 # 501
-  #           HTTPBadGateway                     # 502
-  #           HTTPServiceUnavailable             # 503
-  #           HTTPGatewayTimeOut                 # 504
-  #           HTTPVersionNotSupported            # 505
-  #
-  # == Switching Net::HTTP versions
-  #
-  # You can use net/http.rb 1.1 features (bundled with Ruby 1.6)
-  # by calling HTTP.version_1_1. Calling Net::HTTP.version_1_2
-  # allows you to use 1.2 features again.
-  #
-  #     # example
-  #     Net::HTTP.start {|http1| ...(http1 has 1.2 features)... }
-  #
-  #     Net::HTTP.version_1_1
-  #     Net::HTTP.start {|http2| ...(http2 has 1.1 features)... }
-  #
-  #     Net::HTTP.version_1_2
-  #     Net::HTTP.start {|http3| ...(http3 has 1.2 features)... }
-  #
-  # This function is NOT thread-safe.
+  # Basic authentication is performed according to
+  # [RFC2617](http://www.ietf.org/rfc/rfc2617.txt)
+  #
+  #   uri = URI('http://example.com/index.html?key=value')
+  #
+  #   req = Net::HTTP::Get.new(uri)
+  #   req.basic_auth 'user', 'pass'
+  #
+  #   res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+  #     http.request(req)
+  #   }
+  #   puts res.body
+  #
+  # === Streaming Response Bodies
+  #
+  # By default Net::HTTP reads an entire response into memory.  If you are
+  # handling large files or wish to implement a progress bar you can instead
+  # stream the body directly to an IO.
+  #
+  #   uri = URI('http://example.com/large_file')
+  #
+  #   Net::HTTP.start(uri.host, uri.port) do |http|
+  #     request = Net::HTTP::Get.new uri
+  #
+  #     http.request request do |response|
+  #       open 'large_file', 'w' do |io|
+  #         response.read_body do |chunk|
+  #           io.write chunk
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # === HTTPS
+  #
+  # HTTPS is enabled for an HTTP connection by Net::HTTP#use_ssl=.
+  #
+  #   uri = URI('https://secure.example.com/some_path?query=string')
+  #
+  #   Net::HTTP.start(uri.host, uri.port,
+  #     :use_ssl => uri.scheme == 'https') do |http|
+  #     request = Net::HTTP::Get.new uri
+  #
+  #     response = http.request request # Net::HTTPResponse object
+  #   end
+  #
+  # In previous versions of Ruby you would need to require 'net/https' to use
+  # HTTPS.  This is no longer true.
+  #
+  # === Proxies
+  #
+  # Net::HTTP will automatically create a proxy from the +http_proxy+
+  # environment variable if it is present.  To disable use of +http_proxy+,
+  # pass +nil+ for the proxy address.
+  #
+  # You may also create a custom proxy:
+  #
+  #   proxy_addr = 'your.proxy.host'
+  #   proxy_port = 8080
+  #
+  #   Net::HTTP.new('example.com', nil, proxy_addr, proxy_port).start { |http|
+  #     # always proxy via your.proxy.addr:8080
+  #   }
+  #
+  # See Net::HTTP.new for further details and examples such as proxies that
+  # require a username and password.
+  #
+  # === Compression
+  #
+  # Net::HTTP automatically adds Accept-Encoding for compression of response
+  # bodies and automatically decompresses gzip and deflate responses unless a
+  # Range header was sent.
+  #
+  # Compression can be disabled through the Accept-Encoding: identity header.
+  #
+  # == HTTP Request Classes
+  #
+  # Here is the HTTP request class hierarchy.
+  #
+  # * Net::HTTPRequest
+  #   * Net::HTTP::Get
+  #   * Net::HTTP::Head
+  #   * Net::HTTP::Post
+  #   * Net::HTTP::Patch
+  #   * Net::HTTP::Put
+  #   * Net::HTTP::Proppatch
+  #   * Net::HTTP::Lock
+  #   * Net::HTTP::Unlock
+  #   * Net::HTTP::Options
+  #   * Net::HTTP::Propfind
+  #   * Net::HTTP::Delete
+  #   * Net::HTTP::Move
+  #   * Net::HTTP::Copy
+  #   * Net::HTTP::Mkcol
+  #   * Net::HTTP::Trace
+  #
+  # == HTTP Response Classes
+  #
+  # Here is HTTP response class hierarchy.  All classes are defined in Net
+  # module and are subclasses of Net::HTTPResponse.
+  #
+  # HTTPUnknownResponse:: For unhandled HTTP extensions
+  # HTTPInformation::                    1xx
+  #   HTTPContinue::                        100
+  #   HTTPSwitchProtocol::                  101
+  # HTTPSuccess::                        2xx
+  #   HTTPOK::                              200
+  #   HTTPCreated::                         201
+  #   HTTPAccepted::                        202
+  #   HTTPNonAuthoritativeInformation::     203
+  #   HTTPNoContent::                       204
+  #   HTTPResetContent::                    205
+  #   HTTPPartialContent::                  206
+  #   HTTPMultiStatus::                     207
+  # HTTPRedirection::                    3xx
+  #   HTTPMultipleChoices::                 300
+  #   HTTPMovedPermanently::                301
+  #   HTTPFound::                           302
+  #   HTTPSeeOther::                        303
+  #   HTTPNotModified::                     304
+  #   HTTPUseProxy::                        305
+  #   HTTPTemporaryRedirect::               307
+  # HTTPClientError::                    4xx
+  #   HTTPBadRequest::                      400
+  #   HTTPUnauthorized::                    401
+  #   HTTPPaymentRequired::                 402
+  #   HTTPForbidden::                       403
+  #   HTTPNotFound::                        404
+  #   HTTPMethodNotAllowed::                405
+  #   HTTPNotAcceptable::                   406
+  #   HTTPProxyAuthenticationRequired::     407
+  #   HTTPRequestTimeOut::                  408
+  #   HTTPConflict::                        409
+  #   HTTPGone::                            410
+  #   HTTPLengthRequired::                  411
+  #   HTTPPreconditionFailed::              412
+  #   HTTPRequestEntityTooLarge::           413
+  #   HTTPRequestURITooLong::               414
+  #   HTTPUnsupportedMediaType::            415
+  #   HTTPRequestedRangeNotSatisfiable::    416
+  #   HTTPExpectationFailed::               417
+  #   HTTPUnprocessableEntity::             422
+  #   HTTPLocked::                          423
+  #   HTTPFailedDependency::                424
+  #   HTTPUpgradeRequired::                 426
+  #   HTTPPreconditionRequired::            428
+  #   HTTPTooManyRequests::                 429
+  #   HTTPRequestHeaderFieldsTooLarge::     431
+  # HTTPServerError::                    5xx
+  #   HTTPInternalServerError::             500
+  #   HTTPNotImplemented::                  501
+  #   HTTPBadGateway::                      502
+  #   HTTPServiceUnavailable::              503
+  #   HTTPGatewayTimeOut::                  504
+  #   HTTPVersionNotSupported::             505
+  #   HTTPInsufficientStorage::             507
+  #   HTTPNetworkAuthenticationRequired::   511
+  #
+  # There is also the Net::HTTPBadResponse exception which is raised when
+  # there is a protocol error.
   #
   class HTTP < Protocol
 
     # :stopdoc:
-    Revision = %q$Revision$.split[1]
+    Revision = %q$Revision: 42169 $.split[1]
     HTTPVersion = '1.1'
-    @newimpl = true
+    begin
+      require 'zlib'
+      require 'stringio'  #for our purposes (unpacking gzip) lump these together
+      HAVE_ZLIB=true
+    rescue LoadError
+      HAVE_ZLIB=false
+    end
     # :startdoc:
 
-    # Turns on net/http 1.2 (ruby 1.8) features.
-    # Defaults to ON in ruby 1.8.
-    #
-    # I strongly recommend to call this method always.
-    #
-    #   require 'net/http'
-    #   Net::HTTP.version_1_2
-    #
+    # Turns on net/http 1.2 (Ruby 1.8) features.
+    # Defaults to ON in Ruby 1.8 or later.
     def HTTP.version_1_2
-      @newimpl = true
+      true
     end
 
-    # Turns on net/http 1.1 (ruby 1.6) features.
-    # Defaults to OFF in ruby 1.8.
-    def HTTP.version_1_1
-      @newimpl = false
-    end
-
-    # true if net/http is in version 1.2 mode.
+    # Returns true if net/http is in version 1.2 mode.
     # Defaults to true.
     def HTTP.version_1_2?
-      @newimpl
+      true
     end
 
-    # true if net/http is in version 1.1 compatible mode.
-    # Defaults to true.
-    def HTTP.version_1_1?
-      not @newimpl
+    def HTTP.version_1_1?  #:nodoc:
+      false
     end
 
     class << HTTP
@@ -323,11 +421,11 @@ module Net   #:nodoc:
     #
 
     #
-    # Get body from target and output it to +$stdout+.  The
-    # target can either be specified as (+uri+), or as
-    # (+host+, +path+, +port+ = 80); so:
+    # Gets the body text from the target and outputs it to $stdout.  The
+    # target can either be specified as
+    # (+uri+), or as (+host+, +path+, +port+ = 80); so:
     #
-    #    Net::HTTP.get_print URI.parse('http://www.example.com/index.html')
+    #    Net::HTTP.get_print URI('http://www.example.com/index.html')
     #
     # or:
     #
@@ -342,11 +440,11 @@ module Net   #:nodoc:
       nil
     end
 
-    # Send a GET request to the target and return the response
+    # Sends a GET request to the target and returns the HTTP response
     # as a string.  The target can either be specified as
     # (+uri+), or as (+host+, +path+, +port+ = 80); so:
     #
-    #    print Net::HTTP.get(URI.parse('http://www.example.com/index.html'))
+    #    print Net::HTTP.get(URI('http://www.example.com/index.html'))
     #
     # or:
     #
@@ -356,11 +454,11 @@ module Net   #:nodoc:
       get_response(uri_or_host, path, port).body
     end
 
-    # Send a GET request to the target and return the response
+    # Sends a GET request to the target and returns the HTTP response
     # as a Net::HTTPResponse object.  The target can either be specified as
     # (+uri+), or as (+host+, +path+, +port+ = 80); so:
     #
-    #    res = Net::HTTP.get_response(URI.parse('http://www.example.com/index.html'))
+    #    res = Net::HTTP.get_response(URI('http://www.example.com/index.html'))
     #    print res.body
     #
     # or:
@@ -376,32 +474,37 @@ module Net   #:nodoc:
         }
       else
         uri = uri_or_host
-        new(uri.host, uri.port).start {|http|
-          return http.request_get(uri.request_uri, &block)
+        start(uri.hostname, uri.port,
+              :use_ssl => uri.scheme == 'https') {|http|
+          return http.request_get(uri, &block)
         }
       end
     end
 
-    # Posts HTML form data to the +URL+.
-    # Form data must be represented as a Hash of String to String, e.g:
+    # Posts HTML form data to the specified URI object.
+    # The form data must be provided as a Hash mapping from String to String.
+    # Example:
     #
     #   { "cmd" => "search", "q" => "ruby", "max" => "50" }
     #
-    # This method also does Basic Authentication iff +URL+.user exists.
+    # This method also does Basic Authentication iff +url+.user exists.
+    # But userinfo for authentication is deprecated (RFC3986).
+    # So this feature will be removed.
     #
     # Example:
     #
     #   require 'net/http'
     #   require 'uri'
     #
-    #   HTTP.post_form URI.parse('http://www.example.com/search.cgi'),
-    #                  { "q" => "ruby", "max" => "50" }
+    #   Net::HTTP.post_form URI('http://www.example.com/search.cgi'),
+    #                       { "q" => "ruby", "max" => "50" }
     #
     def HTTP.post_form(url, params)
-      req = Post.new(url.path)
+      req = Post.new(url)
       req.form_data = params
       req.basic_auth url.user, url.password if url.user
-      new(url.host, url.port).start {|http|
+      start(url.hostname, url.port,
+            :use_ssl => url.scheme == 'https' ) {|http|
         http.request(req)
       }
     end
@@ -429,59 +532,146 @@ module Net   #:nodoc:
       BufferedIO
     end
 
-    # creates a new Net::HTTP object and opens its TCP connection and
-    # HTTP session.  If the optional block is given, the newly
+    # :call-seq:
+    #   HTTP.start(address, port, p_addr, p_port, p_user, p_pass, &block)
+    #   HTTP.start(address, port=nil, p_addr=nil, p_port=nil, p_user=nil, p_pass=nil, opt, &block)
+    #
+    # Creates a new Net::HTTP object, then additionally opens the TCP
+    # connection and HTTP session.
+    #
+    # Arguments are the following:
+    # _address_ :: hostname or IP address of the server
+    # _port_    :: port of the server
+    # _p_addr_  :: address of proxy
+    # _p_port_  :: port of proxy
+    # _p_user_  :: user of proxy
+    # _p_pass_  :: pass of proxy
+    # _opt_     :: optional hash
+    #
+    # _opt_ sets following values by its accessor.
+    # The keys are ca_file, ca_path, cert, cert_store, ciphers,
+    # close_on_empty_response, key, open_timeout, read_timeout, ssl_timeout,
+    # ssl_version, use_ssl, verify_callback, verify_depth and verify_mode.
+    # If you set :use_ssl as true, you can use https and default value of
+    # verify_mode is set as OpenSSL::SSL::VERIFY_PEER.
+    #
+    # If the optional block is given, the newly
     # created Net::HTTP object is passed to it and closed when the
     # block finishes.  In this case, the return value of this method
     # is the return value of the block.  If no block is given, the
     # return value of this method is the newly created Net::HTTP object
-    # itself, and the caller is responsible for closing it upon completion.
-    def HTTP.start(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil, &block) # :yield: +http+
-      new(address, port, p_addr, p_port, p_user, p_pass).start(&block)
+    # itself, and the caller is responsible for closing it upon completion
+    # using the finish() method.
+    def HTTP.start(address, *arg, &block) # :yield: +http+
+      arg.pop if opt = Hash.try_convert(arg[-1])
+      port, p_addr, p_port, p_user, p_pass = *arg
+      port = https_default_port if !port && opt && opt[:use_ssl]
+      http = new(address, port, p_addr, p_port, p_user, p_pass)
+
+      if opt
+        if opt[:use_ssl]
+          opt = {verify_mode: OpenSSL::SSL::VERIFY_PEER}.update(opt)
+        end
+        http.methods.grep(/\A(\w+)=\z/) do |meth|
+          key = $1.to_sym
+          opt.key?(key) or next
+          http.__send__(meth, opt[key])
+        end
+      end
+
+      http.start(&block)
     end
 
     class << HTTP
-      alias newobj new
-    end
+      alias newobj new # :nodoc:
+    end
+
+    # Creates a new Net::HTTP object without opening a TCP connection or
+    # HTTP session.
+    #
+    # The +address+ should be a DNS hostname or IP address, the +port+ is the
+    # port the server operates on.  If no +port+ is given the default port for
+    # HTTP or HTTPS is used.
+    #
+    # If none of the +p_+ arguments are given, the proxy host and port are
+    # taken from the +http_proxy+ environment variable (or its uppercase
+    # equivalent) if present.  If the proxy requires authentication you must
+    # supply it by hand.  See URI::Generic#find_proxy for details of proxy
+    # detection from the environment.  To disable proxy detection set +p_addr+
+    # to nil.
+    #
+    # If you are connecting to a custom proxy, +p_addr+ the DNS name or IP
+    # address of the proxy host, +p_port+ the port to use to access the proxy,
+    # and +p_user+ and +p_pass+ the username and password if authorization is
+    # required to use the proxy.
+    #
+    def HTTP.new(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil)
+      http = super address, port
+
+      if proxy_class? then # from Net::HTTP::Proxy()
+        http.proxy_from_env = @proxy_from_env
+        http.proxy_address  = @proxy_address
+        http.proxy_port     = @proxy_port
+        http.proxy_user     = @proxy_user
+        http.proxy_pass     = @proxy_pass
+      elsif p_addr == :ENV then
+        http.proxy_from_env = true
+      else
+        http.proxy_address = p_addr
+        http.proxy_port    = p_port || default_port
+        http.proxy_user    = p_user
+        http.proxy_pass    = p_pass
+      end
 
-    # Creates a new Net::HTTP object.
-    # If +proxy_addr+ is given, creates an Net::HTTP object with proxy support.
-    # This method does not open the TCP connection.
-    def HTTP.new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)
-      h = Proxy(p_addr, p_port, p_user, p_pass).newobj(address, port)
-      h.instance_eval {
-        @newimpl = ::Net::HTTP.version_1_2?
-      }
-      h
+      http
     end
 
-    # Creates a new Net::HTTP object for the specified +address+.
-    # This method does not open the TCP connection.
+    # Creates a new Net::HTTP object for the specified server address,
+    # without opening the TCP connection or initializing the HTTP session.
+    # The +address+ should be a DNS hostname or IP address.
     def initialize(address, port = nil)
       @address = address
       @port    = (port || HTTP.default_port)
+      @local_host = nil
+      @local_port = nil
       @curr_http_version = HTTPVersion
-      @seems_1_0_server = false
+      @keep_alive_timeout = 2
+      @last_communicated = nil
       @close_on_empty_response = false
       @socket  = nil
       @started = false
       @open_timeout = nil
       @read_timeout = 60
+      @continue_timeout = nil
       @debug_output = nil
+
+      @proxy_from_env = false
+      @proxy_uri      = nil
+      @proxy_address  = nil
+      @proxy_port     = nil
+      @proxy_user     = nil
+      @proxy_pass     = nil
+
       @use_ssl = false
       @ssl_context = nil
+      @ssl_session = nil
+      @enable_post_connection_check = true
+      @sspi_enabled = false
+      SSL_IVNAMES.each do |ivname|
+        instance_variable_set ivname, nil
+      end
     end
 
     def inspect
       "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
     end
 
-    # *WARNING* This method causes serious security hole.
+    # *WARNING* This method opens a serious security hole.
     # Never use this method in production code.
     #
-    # Set an output stream for debugging.
+    # Sets an output stream for debugging.
     #
-    #   http = Net::HTTP.new
+    #   http = Net::HTTP.new(hostname)
     #   http.set_debug_output $stderr
     #   http.start { .... }
     #
@@ -490,20 +680,34 @@ module Net   #:nodoc:
       @debug_output = output
     end
 
-    # The host name to connect to.
+    # The DNS host name or IP address to connect to.
     attr_reader :address
 
     # The port number to connect to.
     attr_reader :port
 
-    # Seconds to wait until connection is opened.
-    # If the HTTP object cannot open a connection in this many seconds,
-    # it raises a TimeoutError exception.
+    # The local host used to estabilish the connection.
+    attr_accessor :local_host
+
+    # The local port used to estabilish the connection.
+    attr_accessor :local_port
+
+    attr_writer :proxy_from_env
+    attr_writer :proxy_address
+    attr_writer :proxy_port
+    attr_writer :proxy_user
+    attr_writer :proxy_pass
+
+    # Number of seconds to wait for the connection to open. Any number
+    # may be used, including Floats for fractional seconds. If the HTTP
+    # object cannot open a connection in this many seconds, it raises a
+    # Net::OpenTimeout exception. The default value is +nil+.
     attr_accessor :open_timeout
 
-    # Seconds to wait until reading one block (by one read(2) call).
-    # If the HTTP object cannot open a connection in this many seconds,
-    # it raises a TimeoutError exception.
+    # Number of seconds to wait for one block to be read (via one read(2)
+    # call). Any number may be used, including Floats for fractional
+    # seconds. If the HTTP object cannot read data in this many seconds,
+    # it raises a Net::ReadTimeout exception. The default value is 60 seconds.
     attr_reader :read_timeout
 
     # Setter for the read_timeout attribute.
@@ -512,7 +716,24 @@ module Net   #:nodoc:
       @read_timeout = sec
     end
 
-    # returns true if the HTTP session is started.
+    # Seconds to wait for 100 Continue response. If the HTTP object does not
+    # receive a response in this many seconds it sends the request body. The
+    # default value is +nil+.
+    attr_reader :continue_timeout
+
+    # Setter for the continue_timeout attribute.
+    def continue_timeout=(sec)
+      @socket.continue_timeout = sec if @socket
+      @continue_timeout = sec
+    end
+
+    # Seconds to reuse the connection of the previous request.
+    # If the idle time is less than this Keep-Alive Timeout,
+    # Net::HTTP reuses the TCP/IP socket used by the previous communication.
+    # The default value is 2 seconds.
+    attr_accessor :keep_alive_timeout
+
+    # Returns true if the HTTP session has been started.
     def started?
       @started
     end
@@ -521,19 +742,107 @@ module Net   #:nodoc:
 
     attr_accessor :close_on_empty_response
 
-    # returns true if use SSL/TLS with HTTP.
+    # Returns true if SSL/TLS is being used with HTTP.
     def use_ssl?
-      false   # redefined in net/https
+      @use_ssl
+    end
+
+    # Turn on/off SSL.
+    # This flag must be set before starting session.
+    # If you change use_ssl value after session started,
+    # a Net::HTTP object raises IOError.
+    def use_ssl=(flag)
+      flag = flag ? true : false
+      if started? and @use_ssl != flag
+        raise IOError, "use_ssl value changed, but session already started"
+      end
+      @use_ssl = flag
+    end
+
+    SSL_IVNAMES = [
+      :@ca_file,
+      :@ca_path,
+      :@cert,
+      :@cert_store,
+      :@ciphers,
+      :@key,
+      :@ssl_timeout,
+      :@ssl_version,
+      :@verify_callback,
+      :@verify_depth,
+      :@verify_mode,
+    ]
+    SSL_ATTRIBUTES = [
+      :ca_file,
+      :ca_path,
+      :cert,
+      :cert_store,
+      :ciphers,
+      :key,
+      :ssl_timeout,
+      :ssl_version,
+      :verify_callback,
+      :verify_depth,
+      :verify_mode,
+    ]
+
+    # Sets path of a CA certification file in PEM format.
+    #
+    # The file can contain several CA certificates.
+    attr_accessor :ca_file
+
+    # Sets path of a CA certification directory containing certifications in
+    # PEM format.
+    attr_accessor :ca_path
+
+    # Sets an OpenSSL::X509::Certificate object as client certificate.
+    # (This method is appeared in Michal Rokos's OpenSSL extension).
+    attr_accessor :cert
+
+    # Sets the X509::Store to verify peer certificate.
+    attr_accessor :cert_store
+
+    # Sets the available ciphers.  See OpenSSL::SSL::SSLContext#ciphers=
+    attr_accessor :ciphers
+
+    # Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.
+    # (This method is appeared in Michal Rokos's OpenSSL extension.)
+    attr_accessor :key
+
+    # Sets the SSL timeout seconds.
+    attr_accessor :ssl_timeout
+
+    # Sets the SSL version.  See OpenSSL::SSL::SSLContext#ssl_version=
+    attr_accessor :ssl_version
+
+    # Sets the verify callback for the server certification verification.
+    attr_accessor :verify_callback
+
+    # Sets the maximum depth for the certificate chain verification.
+    attr_accessor :verify_depth
+
+    # Sets the flags for server the certification verification at beginning of
+    # SSL/TLS session.
+    #
+    # OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER are acceptable.
+    attr_accessor :verify_mode
+
+    # Returns the X.509 certificates the server presented.
+    def peer_cert
+      if not use_ssl? or not @socket
+        return nil
+      end
+      @socket.io.peer_cert
     end
 
-    # Opens TCP connection and HTTP session.
+    # Opens a TCP connection and HTTP session.
     #
-    # When this method is called with block, gives a HTTP object
-    # to the block and closes the TCP connection / HTTP session
-    # after the block executed.
+    # When this method is called with a block, it passes the Net::HTTP
+    # object to the block, and closes the TCP connection and HTTP session
+    # after the block has been executed.
     #
-    # When called with a block, returns the return value of the
-    # block; otherwise, returns self.
+    # When called with a block, it returns the return value of the
+    # block; otherwise, it returns self.
     #
     def start  # :yield: http
       raise IOError, 'HTTP session already opened' if @started
@@ -556,36 +865,66 @@ module Net   #:nodoc:
     private :do_start
 
     def connect
-      D "opening connection to #{conn_address()}..."
-      s = timeout(@open_timeout) { TCPSocket.open(conn_address(), conn_port()) }
+      if proxy? then
+        conn_address = proxy_address
+        conn_port    = proxy_port
+      else
+        conn_address = address
+        conn_port    = port
+      end
+
+      D "opening connection to #{conn_address}:#{conn_port}..."
+      s = Timeout.timeout(@open_timeout, Net::OpenTimeout) {
+        TCPSocket.open(conn_address, conn_port, @local_host, @local_port)
+      }
+      s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       D "opened"
       if use_ssl?
-        unless @ssl_context.verify_mode
-          warn "warning: peer certificate won't be verified in this SSL session"
-          @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        ssl_parameters = Hash.new
+        iv_list = instance_variables
+        SSL_IVNAMES.each_with_index do |ivname, i|
+          if iv_list.include?(ivname) and
+            value = instance_variable_get(ivname)
+            ssl_parameters[SSL_ATTRIBUTES[i]] = value if value
+          end
         end
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+        @ssl_context.set_params(ssl_parameters)
+        D "starting SSL for #{conn_address}:#{conn_port}..."
         s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
         s.sync_close = true
+        D "SSL established"
       end
       @socket = BufferedIO.new(s)
       @socket.read_timeout = @read_timeout
+      @socket.continue_timeout = @continue_timeout
       @socket.debug_output = @debug_output
       if use_ssl?
-        if proxy?
-          @socket.writeline sprintf('CONNECT %s:%s HTTP/%s',
-                                    @address, @port, HTTPVersion)
-          @socket.writeline "Host: #{@address}:#{@port}"
-          if proxy_user
-            credential = ["#{proxy_user}:#{proxy_pass}"].pack('m')
-            credential.delete!("\r\n")
-            @socket.writeline "Proxy-Authorization: Basic #{credential}"
+        begin
+          if proxy?
+            buf = "CONNECT #{@address}:#{@port} HTTP/#{HTTPVersion}\r\n"
+            buf << "Host: #{@address}:#{@port}\r\n"
+            if proxy_user
+              credential = ["#{proxy_user}:#{proxy_pass}"].pack('m')
+              credential.delete!("\r\n")
+              buf << "Proxy-Authorization: Basic #{credential}\r\n"
+            end
+            buf << "\r\n"
+            @socket.write(buf)
+            HTTPResponse.read_new(@socket).value
           end
-          @socket.writeline ''
-          HTTPResponse.read_new(@socket).value
-        end
-        s.connect
-        if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
-          s.post_connection_check(@address)
+          s.session = @ssl_session if @ssl_session
+          # Server Name Indication (SNI) RFC 3546
+          s.hostname = @address if s.respond_to? :hostname=
+          Timeout.timeout(@open_timeout, Net::OpenTimeout) { s.connect }
+          if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
+            s.post_connection_check(@address)
+          end
+          @ssl_session = s.session
+        rescue => exception
+          D "Conn close because of connect error #{exception}"
+          @socket.close if @socket and not @socket.closed?
+          raise exception
         end
       end
       on_connect
@@ -596,8 +935,8 @@ module Net   #:nodoc:
     end
     private :on_connect
 
-    # Finishes HTTP session and closes TCP connection.
-    # Raises IOError if not started.
+    # Finishes the HTTP session and closes the TCP connection.
+    # Raises IOError if the session has not been started.
     def finish
       raise IOError, 'HTTP session not yet started' unless started?
       do_finish
@@ -618,77 +957,103 @@ module Net   #:nodoc:
 
     # no proxy
     @is_proxy_class = false
+    @proxy_from_env = false
     @proxy_addr = nil
     @proxy_port = nil
     @proxy_user = nil
     @proxy_pass = nil
 
-    # Creates an HTTP proxy class.
-    # Arguments are address/port of proxy host and username/password
-    # if authorization on proxy server is required.
-    # You can replace the HTTP class with created proxy class.
+    # Creates an HTTP proxy class which behaves like Net::HTTP, but
+    # performs all access via the specified proxy.
     #
-    # If ADDRESS is nil, this method returns self (Net::HTTP).
-    #
-    #     # Example
-    #     proxy_class = Net::HTTP::Proxy('proxy.example.com', 8080)
-    #                     :
-    #     proxy_class.start('www.ruby-lang.org') {|http|
-    #       # connecting proxy.foo.org:8080
-    #                     :
-    #     }
-    #
-    def HTTP.Proxy(p_addr, p_port = nil, p_user = nil, p_pass = nil)
+    # This class is obsolete.  You may pass these same parameters directly to
+    # Net::HTTP.new.  See Net::HTTP.new for details of the arguments.
+    def HTTP.Proxy(p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil)
       return self unless p_addr
-      delta = ProxyDelta
-      proxyclass = Class.new(self)
-      proxyclass.module_eval {
-        include delta
-        # with proxy
+
+      Class.new(self) {
         @is_proxy_class = true
-        @proxy_address = p_addr
-        @proxy_port    = p_port || default_port()
-        @proxy_user    = p_user
-        @proxy_pass    = p_pass
+
+        if p_addr == :ENV then
+          @proxy_from_env = true
+          @proxy_address = nil
+          @proxy_port    = nil
+        else
+          @proxy_from_env = false
+          @proxy_address = p_addr
+          @proxy_port    = p_port || default_port
+        end
+
+        @proxy_user = p_user
+        @proxy_pass = p_pass
       }
-      proxyclass
     end
 
     class << HTTP
       # returns true if self is a class which was created by HTTP::Proxy.
       def proxy_class?
-        @is_proxy_class
+        defined?(@is_proxy_class) ? @is_proxy_class : false
       end
 
+      # Address of proxy host. If Net::HTTP does not use a proxy, nil.
       attr_reader :proxy_address
+
+      # Port number of proxy host. If Net::HTTP does not use a proxy, nil.
       attr_reader :proxy_port
+
+      # User name for accessing proxy. If Net::HTTP does not use a proxy, nil.
       attr_reader :proxy_user
+
+      # User password for accessing proxy. If Net::HTTP does not use a proxy,
+      # nil.
       attr_reader :proxy_pass
     end
 
-    # True if self is a HTTP proxy class.
+    # True if requests for this connection will be proxied
     def proxy?
-      self.class.proxy_class?
+      !!if @proxy_from_env then
+        proxy_uri
+      else
+        @proxy_address
+      end
+    end
+
+    # True if the proxy for this connection is determined from the environment
+    def proxy_from_env?
+      @proxy_from_env
+    end
+
+    # The proxy URI determined from the environment for this connection.
+    def proxy_uri # :nodoc:
+      @proxy_uri ||= URI("http://#{address}:#{port}").find_proxy
     end
 
-    # Address of proxy host. If self does not use a proxy, nil.
+    # The address of the proxy server, if one is configured.
     def proxy_address
-      self.class.proxy_address
+      if @proxy_from_env then
+        proxy_uri && proxy_uri.hostname
+      else
+        @proxy_address
+      end
     end
 
-    # Port number of proxy host. If self does not use a proxy, nil.
+    # The port of the proxy server, if one is configured.
     def proxy_port
-      self.class.proxy_port
+      if @proxy_from_env then
+        proxy_uri && proxy_uri.port
+      else
+        @proxy_port
+      end
     end
 
-    # User name for accessing proxy. If self does not use a proxy, nil.
+    # The proxy username, if one is configured
     def proxy_user
-      self.class.proxy_user
+      @proxy_user
     end
 
-    # User password for accessing proxy. If self does not use a proxy, nil.
+    # The proxy password, if one is configured
     def proxy_pass
-      self.class.proxy_pass
+      @proxy_pass
     end
 
     alias proxyaddr proxy_address   #:nodoc: obsolete
@@ -696,33 +1061,21 @@ module Net   #:nodoc:
 
     private
 
-    # without proxy
+    # without proxy, obsolete
 
-    def conn_address
+    def conn_address # :nodoc:
       address()
     end
 
-    def conn_port
+    def conn_port # :nodoc:
       port()
     end
 
     def edit_path(path)
-      path
-    end
-
-    module ProxyDelta   #:nodoc: internal use only
-      private
-
-      def conn_address
-        proxy_address()
-      end
-
-      def conn_port
-        proxy_port()
-      end
-
-      def edit_path(path)
-        use_ssl? ? path : "http://#{addr_port()}#{path}"
+      if proxy? and not use_ssl? then
+        "http://#{addr_port}#{path}"
+      else
+        path
       end
     end
 
@@ -732,13 +1085,23 @@ module Net   #:nodoc:
 
     public
 
-    # Gets data from +path+ on the connected-to host.
-    # +header+ must be a Hash like { 'Accept' => '*/*', ... }.
+    # Retrieves data from +path+ on the connected-to host which may be an
+    # absolute path String or a URI to extract the path from.
+    #
+    # +initheader+ must be a Hash like { 'Accept' => '*/*', ... },
+    # and it defaults to an empty hash.
+    # If +initheader+ doesn't have the key 'accept-encoding', then
+    # a value of "gzip;q=1.0,deflate;q=0.6,identity;q=0.3" is used,
+    # so that gzip compression is used in preference to deflate
+    # compression, which is used in preference to no compression.
+    # Ruby doesn't have libraries to support the compress (Lempel-Ziv)
+    # compression, so that is not supported.  The intent of this is
+    # to reduce bandwidth by default.   If this routine sets up
+    # compression, then it does the decompression also, removing
+    # the header as well to prevent confusion.  Otherwise
+    # it leaves the body as it found it.
     #
-    # In version 1.1 (ruby 1.6), this method returns a pair of objects,
-    # a Net::HTTPResponse object and the entity body string.
-    # In version 1.2 (ruby 1.8), this method returns a Net::HTTPResponse
-    # object.
+    # This method returns a Net::HTTPResponse object.
     #
     # If called with a block, yields each fragment of the
     # entity body in turn as a string as it is read from
@@ -748,16 +1111,8 @@ module Net   #:nodoc:
     # +dest+ argument is obsolete.
     # It still works but you must not use it.
     #
-    # In version 1.1, this method might raise an exception for
-    # 3xx (redirect). In this case you can get a HTTPResponse object
-    # by "anException.response".
-    #
-    # In version 1.2, this method never raises exception.
-    #
-    #     # version 1.1 (bundled with Ruby 1.6)
-    #     response, body = http.get('/index.html')
+    # This method never raises an exception.
     #
-    #     # version 1.2 (bundled with Ruby 1.8 or later)
     #     response = http.get('/index.html')
     #
     #     # using block
@@ -767,17 +1122,12 @@ module Net   #:nodoc:
     #       end
     #     }
     #
-    def get(path, initheader = nil, dest = nil, &block) # :yield: +body_segment+
+    def get(path, initheader = {}, dest = nil, &block) # :yield: +body_segment+
       res = nil
       request(Get.new(path, initheader)) {|r|
         r.read_body dest, &block
         res = r
       }
-      unless @newimpl
-        res.value
-        return res, res.body
-      end
-
       res
     end
 
@@ -786,10 +1136,7 @@ module Net   #:nodoc:
     #
     # This method returns a Net::HTTPResponse object.
     #
-    # In version 1.1, this method might raise an exception for
-    # 3xx (redirect). On the case you can get a HTTPResponse object
-    # by "anException.response".
-    # In version 1.2, this method never raises an exception.
+    # This method never raises an exception.
     #
     #     response = nil
     #     Net::HTTP.start('some.www.server', 80) {|http|
@@ -798,35 +1145,24 @@ module Net   #:nodoc:
     #     p response['content-type']
     #
     def head(path, initheader = nil)
-      res = request(Head.new(path, initheader))
-      res.value unless @newimpl
-      res
+      request(Head.new(path, initheader))
     end
 
     # Posts +data+ (must be a String) to +path+. +header+ must be a Hash
     # like { 'Accept' => '*/*', ... }.
     #
-    # In version 1.1 (ruby 1.6), this method returns a pair of objects, a
-    # Net::HTTPResponse object and an entity body string.
-    # In version 1.2 (ruby 1.8), this method returns a Net::HTTPResponse object.
+    # This method returns a Net::HTTPResponse object.
     #
     # If called with a block, yields each fragment of the
-    # entity body in turn as a string as it are read from
+    # entity body in turn as a string as it is read from
     # the socket.  Note that in this case, the returned response
     # object will *not* contain a (meaningful) body.
     #
     # +dest+ argument is obsolete.
     # It still works but you must not use it.
     #
-    # In version 1.1, this method might raise an exception for
-    # 3xx (redirect). In this case you can get an HTTPResponse object
-    # by "anException.response".
-    # In version 1.2, this method never raises exception.
-    #
-    #     # version 1.1
-    #     response, body = http.post('/cgi-bin/search.rb', 'query=foo')
+    # This method never raises exception.
     #
-    #     # version 1.2
     #     response = http.post('/cgi-bin/search.rb', 'query=foo')
     #
     #     # using block
@@ -841,22 +1177,17 @@ module Net   #:nodoc:
     # "application/x-www-form-urlencoded" by default.
     #
     def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
-      res = nil
-      request(Post.new(path, initheader), data) {|r|
-        r.read_body dest, &block
-        res = r
-      }
-      unless @newimpl
-        res.value
-        return res, res.body
-      end
-      res
+      send_entity(path, data, initheader, dest, Post, &block)
+    end
+
+    # Sends a PATCH request to the +path+ and gets a response,
+    # as an HTTPResponse object.
+    def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
+      send_entity(path, data, initheader, dest, Patch, &block)
     end
 
     def put(path, data, initheader = nil)   #:nodoc:
-      res = request(Put.new(path, initheader), data)
-      res.value unless @newimpl
-      res
+      request(Put.new(path, initheader), data)
     end
 
     # Sends a PROPPATCH request to the +path+ and gets a response,
@@ -919,12 +1250,12 @@ module Net   #:nodoc:
       request(Trace.new(path, initheader))
     end
 
-    # Sends a GET request to the +path+ and gets a response,
-    # as an HTTPResponse object.
+    # Sends a GET request to the +path+.
+    # Returns the response as a Net::HTTPResponse object.
     #
-    # When called with a block, yields an HTTPResponse object.
-    # The body of this response will not have been read yet;
-    # the caller can process it using HTTPResponse#read_body,
+    # When called with a block, passes an HTTPResponse object to the block.
+    # The body of the response will not have been read yet;
+    # the block can process it using HTTPResponse#read_body,
     # if desired.
     #
     # Returns the response.
@@ -932,11 +1263,11 @@ module Net   #:nodoc:
     # This method never raises Net::* exceptions.
     #
     #     response = http.request_get('/index.html')
-    #     # The entity body is already read here.
+    #     # The entity body is already read in this case.
     #     p response['content-type']
     #     puts response.body
     #
-    #     # using block
+    #     # Using a block
     #     http.request_get('/index.html') {|response|
     #       p response['content-type']
     #       response.read_body do |str|   # read body now
@@ -948,8 +1279,8 @@ module Net   #:nodoc:
       request(Get.new(path, initheader), &block)
     end
 
-    # Sends a HEAD request to the +path+ and gets a response,
-    # as an HTTPResponse object.
+    # Sends a HEAD request to the +path+ and returns the response
+    # as a Net::HTTPResponse object.
     #
     # Returns the response.
     #
@@ -962,13 +1293,13 @@ module Net   #:nodoc:
       request(Head.new(path, initheader), &block)
     end
 
-    # Sends a POST request to the +path+ and gets a response,
-    # as an HTTPResponse object.
+    # Sends a POST request to the +path+.
     #
-    # When called with a block, yields an HTTPResponse object.
-    # The body of this response will not have been read yet;
-    # the caller can process it using HTTPResponse#read_body,
-    # if desired.
+    # Returns the response as a Net::HTTPResponse object.
+    #
+    # When called with a block, the block is passed an HTTPResponse
+    # object.  The body of that response will not have been read yet;
+    # the block can process it using HTTPResponse#read_body, if desired.
     #
     # Returns the response.
     #
@@ -977,7 +1308,7 @@ module Net   #:nodoc:
     #     # example
     #     response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')
     #     p response.status
-    #     puts response.body          # body is already read
+    #     puts response.body          # body is already read in this case
     #
     #     # using block
     #     http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|
@@ -1003,9 +1334,9 @@ module Net   #:nodoc:
 
 
     # Sends an HTTP request to the HTTP server.
-    # This method also sends DATA string if DATA is given.
+    # Also sends a DATA string if +data+ is given.
     #
-    # Returns a HTTPResponse object.
+    # Returns a Net::HTTPResponse object.
     #
     # This method never raises Net::* exceptions.
     #
@@ -1017,16 +1348,18 @@ module Net   #:nodoc:
       request r, data
     end
 
-    # Sends an HTTPRequest object REQUEST to the HTTP server.
-    # This method also sends DATA string if REQUEST is a post/put request.
-    # Giving DATA for get/head request causes ArgumentError.
+    # Sends an HTTPRequest object +req+ to the HTTP server.
     #
-    # When called with a block, yields an HTTPResponse object.
-    # The body of this response will not have been read yet;
-    # the caller can process it using HTTPResponse#read_body,
-    # if desired.
+    # If +req+ is a Net::HTTP::Post or Net::HTTP::Put request containing
+    # data, the data is also sent. Providing data for a Net::HTTP::Head or
+    # Net::HTTP::Get request results in an ArgumentError.
+    #
+    # Returns an HTTPResponse object.
     #
-    # Returns a HTTPResponse object.
+    # When called with a block, passes an HTTPResponse object to the block.
+    # The body of the response will not have been read yet;
+    # the block can process it using HTTPResponse#read_body,
+    # if desired.
     #
     # This method never raises Net::* exceptions.
     #
@@ -1038,57 +1371,107 @@ module Net   #:nodoc:
         }
       end
       if proxy_user()
-        unless use_ssl?
-          req.proxy_basic_auth proxy_user(), proxy_pass()
-        end
+        req.proxy_basic_auth proxy_user(), proxy_pass() unless use_ssl?
       end
-
       req.set_body_internal body
+      res = transport_request(req, &block)
+      if sspi_auth?(res)
+        sspi_auth(req)
+        res = transport_request(req, &block)
+      end
+      res
+    end
+
+    private
+
+    # Executes a request which uses a representation
+    # and returns its body.
+    def send_entity(path, data, initheader, dest, type, &block)
+      res = nil
+      request(type.new(path, initheader), data) {|r|
+        r.read_body dest, &block
+        res = r
+      }
+      res
+    end
+
+    IDEMPOTENT_METHODS_ = %w/GET HEAD PUT DELETE OPTIONS TRACE/ # :nodoc:
+
+    def transport_request(req)
+      count = 0
       begin
         begin_transport req
-        req.exec @socket, @curr_http_version, edit_path(req.path)
-        begin
-          res = HTTPResponse.read_new(@socket)
-        end while res.kind_of?(HTTPContinue)
-        res.reading_body(@socket, req.response_body_permitted?) {
-          yield res if block_given?
+        res = catch(:response) {
+          req.exec @socket, @curr_http_version, edit_path(req.path)
+          begin
+            res = HTTPResponse.read_new(@socket)
+            res.decode_content = req.decode_content
+          end while res.kind_of?(HTTPContinue)
+
+          res.uri = req.uri
+
+          res.reading_body(@socket, req.response_body_permitted?) {
+            yield res if block_given?
+          }
+          res
         }
-        end_transport req, res
-      rescue => exception
+      rescue Net::OpenTimeout
+        raise
+      rescue Net::ReadTimeout, IOError, EOFError,
+             Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE,
+             # avoid a dependency on OpenSSL
+             defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
+             Timeout::Error => exception
+        if count == 0 && IDEMPOTENT_METHODS_.include?(req.method)
+          count += 1
+          @socket.close if @socket and not @socket.closed?
+          D "Conn close because of error #{exception}, and retry"
+          retry
+        end
         D "Conn close because of error #{exception}"
         @socket.close if @socket and not @socket.closed?
-        raise exception
+        raise
       end
 
+      end_transport req, res
       res
+    rescue => exception
+      D "Conn close because of error #{exception}"
+      @socket.close if @socket and not @socket.closed?
+      raise exception
     end
 
-    private
-
     def begin_transport(req)
       if @socket.closed?
         connect
+      elsif @last_communicated && @last_communicated + @keep_alive_timeout < Time.now
+        D 'Conn close because of keep_alive_timeout'
+        @socket.close
+        connect
       end
-      if @seems_1_0_server
-        req['connection'] ||= 'close'
-      end
+
       if not req.response_body_permitted? and @close_on_empty_response
         req['connection'] ||= 'close'
       end
+
+      host = req['host'] || address
+      host = $1 if host =~ /(.*):\d+$/
+      req.update_uri host, port, use_ssl?
+
       req['host'] ||= addr_port()
     end
 
     def end_transport(req, res)
       @curr_http_version = res.http_version
-      if not res.body and @close_on_empty_response
+      @last_communicated = nil
+      if @socket.closed?
+        D 'Conn socket closed'
+      elsif not res.body and @close_on_empty_response
         D 'Conn close'
         @socket.close
       elsif keep_alive?(req, res)
         D 'Conn keep-alive'
-        if @socket.closed?
-          D 'Conn (but seems 1.0 server)'
-          @seems_1_0_server = true
-        end
+        @last_communicated = Time.now
       else
         D 'Conn close'
         @socket.close
@@ -1096,13 +1479,40 @@ module Net   #:nodoc:
     end
 
     def keep_alive?(req, res)
-      return false if /close/i =~ req['connection'].to_s
-      return false if @seems_1_0_server
-      return true  if /keep-alive/i =~ res['connection'].to_s
-      return false if /close/i      =~ res['connection'].to_s
-      return true  if /keep-alive/i =~ res['proxy-connection'].to_s
-      return false if /close/i      =~ res['proxy-connection'].to_s
-      (@curr_http_version == '1.1')
+      return false if req.connection_close?
+      if @curr_http_version <= '1.0'
+        res.connection_keep_alive?
+      else   # HTTP/1.1 or later
+        not res.connection_close?
+      end
+    end
+
+    def sspi_auth?(res)
+      return false unless @sspi_enabled
+      if res.kind_of?(HTTPProxyAuthenticationRequired) and
+          proxy? and res["Proxy-Authenticate"].include?("Negotiate")
+        begin
+          require 'win32/sspi'
+          true
+        rescue LoadError
+          false
+        end
+      else
+        false
+      end
+    end
+
+    def sspi_auth(req)
+      n = Win32::SSPI::NegotiateAuth.new
+      req["Proxy-Authorization"] = "Negotiate #{n.get_initial_token}"
+      # Some versions of ISA will close the connection if this isn't present.
+      req["Connection"] = "Keep-Alive"
+      req["Proxy-Connection"] = "Keep-Alive"
+      res = transport_request(req)
+      authphrase = res["Proxy-Authenticate"]  or return res
+      req["Proxy-Authorization"] = "Negotiate #{n.complete_authentication(authphrase)}"
+    rescue => err
+      raise HTTPAuthenticationError.new('HTTP authentication failed', err)
     end
 
     #
@@ -1124,1167 +1534,22 @@ module Net   #:nodoc:
       @debug_output << msg
       @debug_output << "\n"
     end
-
   end
 
-  HTTPSession = HTTP
-
-
-  #
-  # Header module.
-  #
-  # Provides access to @header in the mixed-into class as a hash-like
-  # object, except with case-insensitive keys.  Also provides
-  # methods for accessing commonly-used header values in a more
-  # convenient format.
-  #
-  module HTTPHeader
-
-    def initialize_http_header(initheader)
-      @header = {}
-      return unless initheader
-      initheader.each do |key, value|
-        warn "net/http: warning: duplicated HTTP header: #{key}" if key?(key) and $VERBOSE
-        @header[key.downcase] = [value.strip]
-      end
-    end
-
-    def size   #:nodoc: obsolete
-      @header.size
-    end
-
-    alias length size   #:nodoc: obsolete
-
-    # Returns the header field corresponding to the case-insensitive key.
-    # For example, a key of "Content-Type" might return "text/html"
-    def [](key)
-      a = @header[key.downcase] or return nil
-      a.join(', ')
-    end
-
-    # Sets the header field corresponding to the case-insensitive key.
-    def []=(key, val)
-      unless val
-        @header.delete key.downcase
-        return val
-      end
-      @header[key.downcase] = [val]
-    end
-
-    # [Ruby 1.8.3]
-    # Adds header field instead of replace.
-    # Second argument +val+ must be a String.
-    # See also #[]=, #[] and #get_fields.
-    #
-    #   request.add_field 'X-My-Header', 'a'
-    #   p request['X-My-Header']              #=> "a"
-    #   p request.get_fields('X-My-Header')   #=> ["a"]
-    #   request.add_field 'X-My-Header', 'b'
-    #   p request['X-My-Header']              #=> "a, b"
-    #   p request.get_fields('X-My-Header')   #=> ["a", "b"]
-    #   request.add_field 'X-My-Header', 'c'
-    #   p request['X-My-Header']              #=> "a, b, c"
-    #   p request.get_fields('X-My-Header')   #=> ["a", "b", "c"]
-    #
-    def add_field(key, val)
-      if @header.key?(key.downcase)
-        @header[key.downcase].push val
-      else
-        @header[key.downcase] = [val]
-      end
-    end
-
-    # [Ruby 1.8.3]
-    # Returns an array of header field strings corresponding to the
-    # case-insensitive +key+.  This method allows you to get duplicated
-    # header fields without any processing.  See also #[].
-    #
-    #   p response.get_fields('Set-Cookie')
-    #     #=> ["session=al98axx; expires=Fri, 31-Dec-1999 23:58:23",
-    #          "query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"]
-    #   p response['Set-Cookie']
-    #     #=> "session=al98axx; expires=Fri, 31-Dec-1999 23:58:23, query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"
-    #
-    def get_fields(key)
-      return nil unless @header[key.downcase]
-      @header[key.downcase].dup
-    end
-
-    # Returns the header field corresponding to the case-insensitive key.
-    # Returns the default value +args+, or the result of the block, or nil,
-    # if there's no header field named key.  See Hash#fetch
-    def fetch(key, *args, &block)   #:yield: +key+
-      a = @header.fetch(key.downcase, *args, &block)
-      a.join(', ')
-    end
-
-    # Iterates for each header names and values.
-    def each_header   #:yield: +key+, +value+
-      return to_enum(__method__) unless block_given?
-      @header.each do |k,va|
-        yield k, va.join(', ')
-      end
-    end
-
-    alias each each_header
-
-    # Iterates for each header names.
-    def each_name(&block)   #:yield: +key+
-      return to_enum(__method__) unless block_given?
-      @header.each_key(&block)
-    end
-
-    alias each_key each_name
-
-    # Iterates for each capitalized header names.
-    def each_capitalized_name(&block)   #:yield: +key+
-      return to_enum(__method__) unless block_given?
-      @header.each_key do |k|
-        yield capitalize(k)
-      end
-    end
-
-    # Iterates for each header values.
-    def each_value   #:yield: +value+
-      return to_enum(__method__) unless block_given?
-      @header.each_value do |va|
-        yield va.join(', ')
-      end
-    end
-
-    # Removes a header field.
-    def delete(key)
-      @header.delete(key.downcase)
-    end
-
-    # true if +key+ header exists.
-    def key?(key)
-      @header.key?(key.downcase)
-    end
-
-    # Returns a Hash consist of header names and values.
-    def to_hash
-      @header.dup
-    end
-
-    # As for #each_header, except the keys are provided in capitalized form.
-    def each_capitalized
-      return to_enum(__method__) unless block_given?
-      @header.each do |k,v|
-        yield capitalize(k), v.join(', ')
-      end
-    end
-
-    alias canonical_each each_capitalized
+end
 
-    def capitalize(name)
-      name.split(/-/).map {|s| s.capitalize }.join('-')
-    end
-    private :capitalize
-
-    # Returns an Array of Range objects which represents Range: header field,
-    # or +nil+ if there is no such header.
-    def range
-      return nil unless @header['range']
-      self['Range'].split(/,/).map {|spec|
-        m = /bytes\s*=\s*(\d+)?\s*-\s*(\d+)?/i.match(spec) or
-                raise HTTPHeaderSyntaxError, "wrong Range: #{spec}"
-        d1 = m[1].to_i
-        d2 = m[2].to_i
-        if    m[1] and m[2] then  d1..d2
-        elsif m[1]          then  d1..-1
-        elsif          m[2] then -d2..-1
-        else
-          raise HTTPHeaderSyntaxError, 'range is not specified'
-        end
-      }
-    end
-
-    # Set Range: header from Range (arg r) or beginning index and
-    # length from it (arg idx&len).
-    #
-    #   req.range = (0..1023)
-    #   req.set_range 0, 1023
-    #
-    def set_range(r, e = nil)
-      unless r
-        @header.delete 'range'
-        return r
-      end
-      r = (r...r+e) if e
-      case r
-      when Numeric
-        n = r.to_i
-        rangestr = (n > 0 ? "0-#{n-1}" : "-#{-n}")
-      when Range
-        first = r.first
-        last = r.last
-        last -= 1 if r.exclude_end?
-        if last == -1
-          rangestr = (first > 0 ? "#{first}-" : "-#{-first}")
-        else
-          raise HTTPHeaderSyntaxError, 'range.first is negative' if first < 0
-          raise HTTPHeaderSyntaxError, 'range.last is negative' if last < 0
-          raise HTTPHeaderSyntaxError, 'must be .first < .last' if first > last
-          rangestr = "#{first}-#{last}"
-        end
-      else
-        raise TypeError, 'Range/Integer is required'
-      end
-      @header['range'] = ["bytes=#{rangestr}"]
-      r
-    end
-
-    alias range= set_range
+require 'net/http/exceptions'
 
-    # Returns an Integer object which represents the Content-Length: header field
-    # or +nil+ if that field is not provided.
-    def content_length
-      return nil unless key?('Content-Length')
-      len = self['Content-Length'].slice(/\d+/) or
-          raise HTTPHeaderSyntaxError, 'wrong Content-Length format'
-      len.to_i
-    end
-
-    def content_length=(len)
-      unless len
-        @header.delete 'content-length'
-        return nil
-      end
-      @header['content-length'] = [len.to_i.to_s]
-    end
-
-    # Returns "true" if the "transfer-encoding" header is present and
-    # set to "chunked".  This is an HTTP/1.1 feature, allowing the
-    # the content to be sent in "chunks" without at the outset
-    # stating the entire content length.
-    def chunked?
-      return false unless @header['transfer-encoding']
-      field = self['Transfer-Encoding']
-      (/(?:\A|[^\-\w])chunked(?![\-\w])/i =~ field) ? true : false
-    end
-
-    # Returns a Range object which represents Content-Range: header field.
-    # This indicates, for a partial entity body, where this fragment
-    # fits inside the full entity body, as range of byte offsets.
-    def content_range
-      return nil unless @header['content-range']
-      m = %r<bytes\s+(\d+)-(\d+)/(\d+|\*)>i.match(self['Content-Range']) or
-          raise HTTPHeaderSyntaxError, 'wrong Content-Range format'
-      m[1].to_i .. m[2].to_i
-    end
-
-    # The length of the range represented in Content-Range: header.
-    def range_length
-      r = content_range() or return nil
-      r.end - r.begin + 1
-    end
-
-    # Returns a content type string such as "text/html".
-    # This method returns nil if Content-Type: header field does not exist.
-    def content_type
-      return nil unless main_type()
-      if sub_type()
-      then "#{main_type()}/#{sub_type()}"
-      else main_type()
-      end
-    end
-
-    # Returns a content type string such as "text".
-    # This method returns nil if Content-Type: header field does not exist.
-    def main_type
-      return nil unless @header['content-type']
-      self['Content-Type'].split(';').first.to_s.split('/')[0].to_s.strip
-    end
-
-    # Returns a content type string such as "html".
-    # This method returns nil if Content-Type: header field does not exist
-    # or sub-type is not given (e.g. "Content-Type: text").
-    def sub_type
-      return nil unless @header['content-type']
-      main, sub = *self['Content-Type'].split(';').first.to_s.split('/')
-      return nil unless sub
-      sub.strip
-    end
-
-    # Returns content type parameters as a Hash as like
-    # {"charset" => "iso-2022-jp"}.
-    def type_params
-      result = {}
-      list = self['Content-Type'].to_s.split(';')
-      list.shift
-      list.each do |param|
-        k, v = *param.split('=', 2)
-        result[k.strip] = v.strip
-      end
-      result
-    end
-
-    # Set Content-Type: header field by +type+ and +params+.
-    # +type+ must be a String, +params+ must be a Hash.
-    def set_content_type(type, params = {})
-      @header['content-type'] = [type + params.map{|k,v|"; #{k}=#{v}"}.join('')]
-    end
-
-    alias content_type= set_content_type
+require 'net/http/header'
 
-    # Set header fields and a body from HTML form data.
-    # +params+ should be a Hash containing HTML form data.
-    # Optional argument +sep+ means data record separator.
-    #
-    # This method also set Content-Type: header field to
-    # application/x-www-form-urlencoded.
-    def set_form_data(params, sep = '&')
-      self.body = params.map {|k,v| "#{urlencode(k.to_s)}=#{urlencode(v.to_s)}" }.join(sep)
-      self.content_type = 'application/x-www-form-urlencoded'
-    end
+require 'net/http/generic_request'
+require 'net/http/request'
+require 'net/http/requests'
 
-    alias form_data= set_form_data
-
-    def urlencode(str)
-      str.gsub(/[^a-zA-Z0-9_\.\-]/n) {|s| sprintf('%%%02x', s[0]) }
-    end
-    private :urlencode
+require 'net/http/response'
+require 'net/http/responses'
 
-    # Set the Authorization: header for "Basic" authorization.
-    def basic_auth(account, password)
-      @header['authorization'] = [basic_encode(account, password)]
-    end
-
-    # Set Proxy-Authorization: header for "Basic" authorization.
-    def proxy_basic_auth(account, password)
-      @header['proxy-authorization'] = [basic_encode(account, password)]
-    end
-
-    def basic_encode(account, password)
-      'Basic ' + ["#{account}:#{password}"].pack('m').delete("\r\n")
-    end
-    private :basic_encode
-
-  end
-
-
-  #
-  # Parent of HTTPRequest class.  Do not use this directly; use
-  # a subclass of HTTPRequest.
-  #
-  # Mixes in the HTTPHeader module.
-  #
-  class HTTPGenericRequest
-
-    include HTTPHeader
-
-    BUFSIZE = 16*1024
-
-    def initialize(m, reqbody, resbody, path, initheader = nil)
-      @method = m
-      @request_has_body = reqbody
-      @response_has_body = resbody
-      raise ArgumentError, "HTTP request path is empty" if path.empty?
-      @path = path
-      initialize_http_header initheader
-      self['Accept'] ||= '*/*'
-      @body = nil
-      @body_stream = nil
-    end
-
-    attr_reader :method
-    attr_reader :path
-
-    def inspect
-      "\#<#{self.class} #{@method}>"
-    end
-
-    def request_body_permitted?
-      @request_has_body
-    end
-
-    def response_body_permitted?
-      @response_has_body
-    end
-
-    def body_exist?
-      warn "Net::HTTPRequest#body_exist? is obsolete; use response_body_permitted?" if $VERBOSE
-      response_body_permitted?
-    end
-
-    attr_reader :body
-
-    def body=(str)
-      @body = str
-      @body_stream = nil
-      str
-    end
-
-    attr_reader :body_stream
-
-    def body_stream=(input)
-      @body = nil
-      @body_stream = input
-      input
-    end
-
-    def set_body_internal(str)   #:nodoc: internal use only
-      raise ArgumentError, "both of body argument and HTTPRequest#body set" if str and (@body or @body_stream)
-      self.body = str if str
-    end
-
-    #
-    # write
-    #
-
-    def exec(sock, ver, path)   #:nodoc: internal use only
-      if @body
-        send_request_with_body sock, ver, path, @body
-      elsif @body_stream
-        send_request_with_body_stream sock, ver, path, @body_stream
-      else
-        write_header sock, ver, path
-      end
-    end
-
-    private
-
-    def send_request_with_body(sock, ver, path, body)
-      self.content_length = body.length
-      delete 'Transfer-Encoding'
-      supply_default_content_type
-      write_header sock, ver, path
-      sock.write body
-    end
-
-    def send_request_with_body_stream(sock, ver, path, f)
-      unless content_length() or chunked?
-        raise ArgumentError,
-            "Content-Length not given and Transfer-Encoding is not `chunked'"
-      end
-      supply_default_content_type
-      write_header sock, ver, path
-      if chunked?
-        while s = f.read(BUFSIZE)
-          sock.write(sprintf("%x\r\n", s.length) << s << "\r\n")
-        end
-        sock.write "0\r\n\r\n"
-      else
-        while s = f.read(BUFSIZE)
-          sock.write s
-        end
-      end
-    end
-
-    def supply_default_content_type
-      return if content_type()
-      warn 'net/http: warning: Content-Type did not set; using application/x-www-form-urlencoded' if $VERBOSE
-      set_content_type 'application/x-www-form-urlencoded'
-    end
-
-    def write_header(sock, ver, path)
-      buf = "#{@method} #{path} HTTP/#{ver}\r\n"
-      each_capitalized do |k,v|
-        buf << "#{k}: #{v}\r\n"
-      end
-      buf << "\r\n"
-      sock.write buf
-    end
-
-  end
-
-
-  #
-  # HTTP request class. This class wraps request header and entity path.
-  # You *must* use its subclass, Net::HTTP::Get, Post, Head.
-  #
-  class HTTPRequest < HTTPGenericRequest
-
-    # Creates HTTP request object.
-    def initialize(path, initheader = nil)
-      super self.class::METHOD,
-            self.class::REQUEST_HAS_BODY,
-            self.class::RESPONSE_HAS_BODY,
-            path, initheader
-    end
-  end
-
-
-  class HTTP   # reopen
-    #
-    # HTTP 1.1 methods --- RFC2616
-    #
-
-    class Get < HTTPRequest
-      METHOD = 'GET'
-      REQUEST_HAS_BODY  = false
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Head < HTTPRequest
-      METHOD = 'HEAD'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = false
-    end
-
-    class Post < HTTPRequest
-      METHOD = 'POST'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Put < HTTPRequest
-      METHOD = 'PUT'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Delete < HTTPRequest
-      METHOD = 'DELETE'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Options < HTTPRequest
-      METHOD = 'OPTIONS'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = false
-    end
-
-    class Trace < HTTPRequest
-      METHOD = 'TRACE'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-
-    #
-    # WebDAV methods --- RFC2518
-    #
-
-    class Propfind < HTTPRequest
-      METHOD = 'PROPFIND'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Proppatch < HTTPRequest
-      METHOD = 'PROPPATCH'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Mkcol < HTTPRequest
-      METHOD = 'MKCOL'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Copy < HTTPRequest
-      METHOD = 'COPY'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Move < HTTPRequest
-      METHOD = 'MOVE'
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Lock < HTTPRequest
-      METHOD = 'LOCK'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-
-    class Unlock < HTTPRequest
-      METHOD = 'UNLOCK'
-      REQUEST_HAS_BODY = true
-      RESPONSE_HAS_BODY = true
-    end
-  end
-
-
-  ###
-  ### Response
-  ###
-
-  # HTTP exception class.
-  # You must use its subclasses.
-  module HTTPExceptions
-    def initialize(msg, res)   #:nodoc:
-      super msg
-      @response = res
-    end
-    attr_reader :response
-    alias data response    #:nodoc: obsolete
-  end
-  class HTTPError < ProtocolError
-    include HTTPExceptions
-  end
-  class HTTPRetriableError < ProtoRetriableError
-    include HTTPExceptions
-  end
-  class HTTPServerException < ProtoServerError
-    # We cannot use the name "HTTPServerError", it is the name of the response.
-    include HTTPExceptions
-  end
-  class HTTPFatalError < ProtoFatalError
-    include HTTPExceptions
-  end
-
-
-  # HTTP response class. This class wraps response header and entity.
-  # Mixes in the HTTPHeader module, which provides access to response
-  # header values both via hash-like methods and individual readers.
-  # Note that each possible HTTP response code defines its own
-  # HTTPResponse subclass.  These are listed below.
-  # All classes are
-  # defined under the Net module. Indentation indicates inheritance.
-  #
-  #   xxx        HTTPResponse
-  #
-  #     1xx        HTTPInformation
-  #       100        HTTPContinue
-  #       101        HTTPSwitchProtocol
-  #
-  #     2xx        HTTPSuccess
-  #       200        HTTPOK
-  #       201        HTTPCreated
-  #       202        HTTPAccepted
-  #       203        HTTPNonAuthoritativeInformation
-  #       204        HTTPNoContent
-  #       205        HTTPResetContent
-  #       206        HTTPPartialContent
-  #
-  #     3xx        HTTPRedirection
-  #       300        HTTPMultipleChoice
-  #       301        HTTPMovedPermanently
-  #       302        HTTPFound
-  #       303        HTTPSeeOther
-  #       304        HTTPNotModified
-  #       305        HTTPUseProxy
-  #       307        HTTPTemporaryRedirect
-  #
-  #     4xx        HTTPClientError
-  #       400        HTTPBadRequest
-  #       401        HTTPUnauthorized
-  #       402        HTTPPaymentRequired
-  #       403        HTTPForbidden
-  #       404        HTTPNotFound
-  #       405        HTTPMethodNotAllowed
-  #       406        HTTPNotAcceptable
-  #       407        HTTPProxyAuthenticationRequired
-  #       408        HTTPRequestTimeOut
-  #       409        HTTPConflict
-  #       410        HTTPGone
-  #       411        HTTPLengthRequired
-  #       412        HTTPPreconditionFailed
-  #       413        HTTPRequestEntityTooLarge
-  #       414        HTTPRequestURITooLong
-  #       415        HTTPUnsupportedMediaType
-  #       416        HTTPRequestedRangeNotSatisfiable
-  #       417        HTTPExpectationFailed
-  #
-  #     5xx        HTTPServerError
-  #       500        HTTPInternalServerError
-  #       501        HTTPNotImplemented
-  #       502        HTTPBadGateway
-  #       503        HTTPServiceUnavailable
-  #       504        HTTPGatewayTimeOut
-  #       505        HTTPVersionNotSupported
-  #
-  #     xxx        HTTPUnknownResponse
-  #
-  class HTTPResponse
-    # true if the response has body.
-    def HTTPResponse.body_permitted?
-      self::HAS_BODY
-    end
-
-    def HTTPResponse.exception_type   # :nodoc: internal use only
-      self::EXCEPTION_TYPE
-    end
-  end   # reopened after
-
-  # :stopdoc:
-
-  class HTTPUnknownResponse < HTTPResponse
-    HAS_BODY = true
-    EXCEPTION_TYPE = HTTPError
-  end
-  class HTTPInformation < HTTPResponse           # 1xx
-    HAS_BODY = false
-    EXCEPTION_TYPE = HTTPError
-  end
-  class HTTPSuccess < HTTPResponse               # 2xx
-    HAS_BODY = true
-    EXCEPTION_TYPE = HTTPError
-  end
-  class HTTPRedirection < HTTPResponse           # 3xx
-    HAS_BODY = true
-    EXCEPTION_TYPE = HTTPRetriableError
-  end
-  class HTTPClientError < HTTPResponse           # 4xx
-    HAS_BODY = true
-    EXCEPTION_TYPE = HTTPServerException   # for backward compatibility
-  end
-  class HTTPServerError < HTTPResponse           # 5xx
-    HAS_BODY = true
-    EXCEPTION_TYPE = HTTPFatalError    # for backward compatibility
-  end
-
-  class HTTPContinue < HTTPInformation           # 100
-    HAS_BODY = false
-  end
-  class HTTPSwitchProtocol < HTTPInformation     # 101
-    HAS_BODY = false
-  end
-
-  class HTTPOK < HTTPSuccess                            # 200
-    HAS_BODY = true
-  end
-  class HTTPCreated < HTTPSuccess                       # 201
-    HAS_BODY = true
-  end
-  class HTTPAccepted < HTTPSuccess                      # 202
-    HAS_BODY = true
-  end
-  class HTTPNonAuthoritativeInformation < HTTPSuccess   # 203
-    HAS_BODY = true
-  end
-  class HTTPNoContent < HTTPSuccess                     # 204
-    HAS_BODY = false
-  end
-  class HTTPResetContent < HTTPSuccess                  # 205
-    HAS_BODY = false
-  end
-  class HTTPPartialContent < HTTPSuccess                # 206
-    HAS_BODY = true
-  end
-
-  class HTTPMultipleChoice < HTTPRedirection     # 300
-    HAS_BODY = true
-  end
-  class HTTPMovedPermanently < HTTPRedirection   # 301
-    HAS_BODY = true
-  end
-  class HTTPFound < HTTPRedirection              # 302
-    HAS_BODY = true
-  end
-  HTTPMovedTemporarily = HTTPFound
-  class HTTPSeeOther < HTTPRedirection           # 303
-    HAS_BODY = true
-  end
-  class HTTPNotModified < HTTPRedirection        # 304
-    HAS_BODY = false
-  end
-  class HTTPUseProxy < HTTPRedirection           # 305
-    HAS_BODY = false
-  end
-  # 306 unused
-  class HTTPTemporaryRedirect < HTTPRedirection  # 307
-    HAS_BODY = true
-  end
-
-  class HTTPBadRequest < HTTPClientError                    # 400
-    HAS_BODY = true
-  end
-  class HTTPUnauthorized < HTTPClientError                  # 401
-    HAS_BODY = true
-  end
-  class HTTPPaymentRequired < HTTPClientError               # 402
-    HAS_BODY = true
-  end
-  class HTTPForbidden < HTTPClientError                     # 403
-    HAS_BODY = true
-  end
-  class HTTPNotFound < HTTPClientError                      # 404
-    HAS_BODY = true
-  end
-  class HTTPMethodNotAllowed < HTTPClientError              # 405
-    HAS_BODY = true
-  end
-  class HTTPNotAcceptable < HTTPClientError                 # 406
-    HAS_BODY = true
-  end
-  class HTTPProxyAuthenticationRequired < HTTPClientError   # 407
-    HAS_BODY = true
-  end
-  class HTTPRequestTimeOut < HTTPClientError                # 408
-    HAS_BODY = true
-  end
-  class HTTPConflict < HTTPClientError                      # 409
-    HAS_BODY = true
-  end
-  class HTTPGone < HTTPClientError                          # 410
-    HAS_BODY = true
-  end
-  class HTTPLengthRequired < HTTPClientError                # 411
-    HAS_BODY = true
-  end
-  class HTTPPreconditionFailed < HTTPClientError            # 412
-    HAS_BODY = true
-  end
-  class HTTPRequestEntityTooLarge < HTTPClientError         # 413
-    HAS_BODY = true
-  end
-  class HTTPRequestURITooLong < HTTPClientError             # 414
-    HAS_BODY = true
-  end
-  HTTPRequestURITooLarge = HTTPRequestURITooLong
-  class HTTPUnsupportedMediaType < HTTPClientError          # 415
-    HAS_BODY = true
-  end
-  class HTTPRequestedRangeNotSatisfiable < HTTPClientError  # 416
-    HAS_BODY = true
-  end
-  class HTTPExpectationFailed < HTTPClientError             # 417
-    HAS_BODY = true
-  end
-
-  class HTTPInternalServerError < HTTPServerError   # 500
-    HAS_BODY = true
-  end
-  class HTTPNotImplemented < HTTPServerError        # 501
-    HAS_BODY = true
-  end
-  class HTTPBadGateway < HTTPServerError            # 502
-    HAS_BODY = true
-  end
-  class HTTPServiceUnavailable < HTTPServerError    # 503
-    HAS_BODY = true
-  end
-  class HTTPGatewayTimeOut < HTTPServerError        # 504
-    HAS_BODY = true
-  end
-  class HTTPVersionNotSupported < HTTPServerError   # 505
-    HAS_BODY = true
-  end
-
-  # :startdoc:
-
-
-  class HTTPResponse   # reopen
-
-    CODE_CLASS_TO_OBJ = {
-      '1' => HTTPInformation,
-      '2' => HTTPSuccess,
-      '3' => HTTPRedirection,
-      '4' => HTTPClientError,
-      '5' => HTTPServerError
-    }
-    CODE_TO_OBJ = {
-      '100' => HTTPContinue,
-      '101' => HTTPSwitchProtocol,
-
-      '200' => HTTPOK,
-      '201' => HTTPCreated,
-      '202' => HTTPAccepted,
-      '203' => HTTPNonAuthoritativeInformation,
-      '204' => HTTPNoContent,
-      '205' => HTTPResetContent,
-      '206' => HTTPPartialContent,
-
-      '300' => HTTPMultipleChoice,
-      '301' => HTTPMovedPermanently,
-      '302' => HTTPFound,
-      '303' => HTTPSeeOther,
-      '304' => HTTPNotModified,
-      '305' => HTTPUseProxy,
-      '307' => HTTPTemporaryRedirect,
-
-      '400' => HTTPBadRequest,
-      '401' => HTTPUnauthorized,
-      '402' => HTTPPaymentRequired,
-      '403' => HTTPForbidden,
-      '404' => HTTPNotFound,
-      '405' => HTTPMethodNotAllowed,
-      '406' => HTTPNotAcceptable,
-      '407' => HTTPProxyAuthenticationRequired,
-      '408' => HTTPRequestTimeOut,
-      '409' => HTTPConflict,
-      '410' => HTTPGone,
-      '411' => HTTPLengthRequired,
-      '412' => HTTPPreconditionFailed,
-      '413' => HTTPRequestEntityTooLarge,
-      '414' => HTTPRequestURITooLong,
-      '415' => HTTPUnsupportedMediaType,
-      '416' => HTTPRequestedRangeNotSatisfiable,
-      '417' => HTTPExpectationFailed,
-
-      '500' => HTTPInternalServerError,
-      '501' => HTTPNotImplemented,
-      '502' => HTTPBadGateway,
-      '503' => HTTPServiceUnavailable,
-      '504' => HTTPGatewayTimeOut,
-      '505' => HTTPVersionNotSupported
-    }
-
-    class << HTTPResponse
-      def read_new(sock)   #:nodoc: internal use only
-        httpv, code, msg = read_status_line(sock)
-        res = response_class(code).new(httpv, code, msg)
-        each_response_header(sock) do |k,v|
-          res.add_field k, v
-        end
-        res
-      end
-
-      private
-
-      def read_status_line(sock)
-        str = sock.readline
-        m = /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)\s*(.*)\z/in.match(str) or
-          raise HTTPBadResponse, "wrong status line: #{str.dump}"
-        m.captures
-      end
-
-      def response_class(code)
-        CODE_TO_OBJ[code] or
-        CODE_CLASS_TO_OBJ[code[0,1]] or
-        HTTPUnknownResponse
-      end
-
-      def each_response_header(sock)
-        while true
-          line = sock.readuntil("\n", true).sub(/\s+\z/, '')
-          break if line.empty?
-          m = /\A([^:]+):\s*/.match(line) or
-              raise HTTPBadResponse, 'wrong header line format'
-          yield m[1], m.post_match
-        end
-      end
-    end
-
-    # next is to fix bug in RDoc, where the private inside class << self
-    # spills out.
-    public
-
-    include HTTPHeader
-
-    def initialize(httpv, code, msg)   #:nodoc: internal use only
-      @http_version = httpv
-      @code         = code
-      @message      = msg
-      initialize_http_header nil
-      @body = nil
-      @read = false
-    end
-
-    # The HTTP version supported by the server.
-    attr_reader :http_version
-
-    # HTTP result code string. For example, '302'.  You can also
-    # determine the response type by which response subclass the
-    # response object is an instance of.
-    attr_reader :code
-
-    # HTTP result message. For example, 'Not Found'.
-    attr_reader :message
-    alias msg message   # :nodoc: obsolete
-
-    def inspect
-      "#<#{self.class} #{@code} #{@message} readbody=#{@read}>"
-    end
-
-    # For backward compatibility.
-    # To allow Net::HTTP 1.1 style assignment
-    # e.g.
-    #    response, body = Net::HTTP.get(....)
-    #
-    def to_ary
-      warn "net/http.rb: warning: Net::HTTP v1.1 style assignment found at #{caller(1)[0]}; use `response = http.get(...)' instead." if $VERBOSE
-      res = self.dup
-      class << res
-        undef to_ary
-      end
-      [res, res.body]
-    end
-
-    #
-    # response <-> exception relationship
-    #
-
-    def code_type   #:nodoc:
-      self.class
-    end
-
-    def error!   #:nodoc:
-      raise error_type().new(@code + ' ' + @message.dump, self)
-    end
-
-    def error_type   #:nodoc:
-      self.class::EXCEPTION_TYPE
-    end
-
-    # Raises HTTP error if the response is not 2xx.
-    def value
-      error! unless self.kind_of?(HTTPSuccess)
-    end
-
-    #
-    # header (for backward compatibility only; DO NOT USE)
-    #
-
-    def response   #:nodoc:
-      warn "#{caller(1)[0]}: warning: HTTPResponse#response is obsolete" if $VERBOSE
-      self
-    end
-
-    def header   #:nodoc:
-      warn "#{caller(1)[0]}: warning: HTTPResponse#header is obsolete" if $VERBOSE
-      self
-    end
-
-    def read_header   #:nodoc:
-      warn "#{caller(1)[0]}: warning: HTTPResponse#read_header is obsolete" if $VERBOSE
-      self
-    end
-
-    #
-    # body
-    #
-
-    def reading_body(sock, reqmethodallowbody)  #:nodoc: internal use only
-      @socket = sock
-      @body_exist = reqmethodallowbody && self.class.body_permitted?
-      begin
-        yield
-        self.body   # ensure to read body
-      ensure
-        @socket = nil
-      end
-    end
-
-    # Gets entity body.  If the block given, yields it to +block+.
-    # The body is provided in fragments, as it is read in from the socket.
-    #
-    # Calling this method a second or subsequent time will return the
-    # already read string.
-    #
-    #   http.request_get('/index.html') {|res|
-    #     puts res.read_body
-    #   }
-    #
-    #   http.request_get('/index.html') {|res|
-    #     p res.read_body.object_id   # 538149362
-    #     p res.read_body.object_id   # 538149362
-    #   }
-    #
-    #   # using iterator
-    #   http.request_get('/index.html') {|res|
-    #     res.read_body do |segment|
-    #       print segment
-    #     end
-    #   }
-    #
-    def read_body(dest = nil, &block)
-      if @read
-        raise IOError, "#{self.class}\#read_body called twice" if dest or block
-        return @body
-      end
-      to = procdest(dest, block)
-      stream_check
-      if @body_exist
-        read_body_0 to
-        @body = to
-      else
-        @body = nil
-      end
-      @read = true
-
-      @body
-    end
-
-    # Returns the entity body.
-    #
-    # Calling this method a second or subsequent time will return the
-    # already read string.
-    #
-    #   http.request_get('/index.html') {|res|
-    #     puts res.body
-    #   }
-    #
-    #   http.request_get('/index.html') {|res|
-    #     p res.body.object_id   # 538149362
-    #     p res.body.object_id   # 538149362
-    #   }
-    #
-    def body
-      read_body()
-    end
-
-    alias entity body   #:nodoc: obsolete
-
-    private
-
-    def read_body_0(dest)
-      if chunked?
-        read_chunked dest
-        return
-      end
-      clen = content_length()
-      if clen
-        @socket.read clen, dest, true   # ignore EOF
-        return
-      end
-      clen = range_length()
-      if clen
-        @socket.read clen, dest
-        return
-      end
-      @socket.read_all dest
-    end
-
-    def read_chunked(dest)
-      len = nil
-      total = 0
-      while true
-        line = @socket.readline
-        hexlen = line.slice(/[0-9a-fA-F]+/) or
-            raise HTTPBadResponse, "wrong chunk size line: #{line}"
-        len = hexlen.hex
-        break if len == 0
-        @socket.read len, dest; total += len
-        @socket.read 2   # \r\n
-      end
-      until @socket.readline.empty?
-        # none
-      end
-    end
-
-    def stream_check
-      raise IOError, 'attempt to read body out of block' if @socket.closed?
-    end
-
-    def procdest(dest, block)
-      raise ArgumentError, 'both arg and block given for HTTP method' \
-          if dest and block
-      if block
-        ReadAdapter.new(block)
-      else
-        dest || ''
-      end
-    end
-
-  end
-
-
-  # :enddoc:
-
-  #--
-  # for backward compatibility
-  class HTTP
-    ProxyMod = ProxyDelta
-  end
-  module NetPrivate
-    HTTPRequest = ::Net::HTTPRequest
-  end
+require 'net/http/proxy_delta'
 
-  HTTPInformationCode = HTTPInformation
-  HTTPSuccessCode     = HTTPSuccess
-  HTTPRedirectionCode = HTTPRedirection
-  HTTPRetriableCode   = HTTPRedirection
-  HTTPClientErrorCode = HTTPClientError
-  HTTPFatalErrorCode  = HTTPClientError
-  HTTPServerErrorCode = HTTPServerError
-  HTTPResponceReceiver = HTTPResponse
+require 'net/http/backward'
 
-end   # module Net