Class Net::HTTPSession < Protocol

# File ../ruby/lib/net/http.rb, line 880
def HTTP.Proxy(p_addr, 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
    @is_proxy_class = true
    @proxy_address = p_addr
    @proxy_port    = p_port || default_port()
    @proxy_user    = p_user
    @proxy_pass    = p_pass
  }
  proxyclass
end

# File ../ruby/lib/net/http.rb, line 492
def HTTP.default_port
  http_default_port()
end

# File ../ruby/lib/net/http.rb, line 430
def HTTP.get(uri_or_host, path = nil, port = nil)
  get_response(uri_or_host, path, port).body
end

# File ../ruby/lib/net/http.rb, line 411
def HTTP.get_print(uri_or_host, path = nil, port = nil)
  get_response(uri_or_host, path, port) {|res|
    res.read_body do |chunk|
      $stdout.print chunk
    end
  }
  nil
end

# File ../ruby/lib/net/http.rb, line 446
def HTTP.get_response(uri_or_host, path = nil, port = nil, &block)
  if path
    host = uri_or_host
    new(host, port || HTTP.default_port).start {|http|
      return http.request_get(path, &block)
    }
  else
    uri = uri_or_host
    new(uri.hostname, uri.port).start {|http|
      return http.request_get(uri.request_uri, &block)
    }
  end
end

# File ../ruby/lib/net/http.rb, line 497
def HTTP.http_default_port
  80
end

# File ../ruby/lib/net/http.rb, line 502
def HTTP.https_default_port
  443
end

# File ../ruby/lib/net/http.rb, line 568
def HTTP.new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)
  Proxy(p_addr, p_port, p_user, p_pass).newobj(address, port)
end

# File ../ruby/lib/net/http.rb, line 575
def initialize(address, port = nil)
  @address = address
  @port    = (port || HTTP.default_port)
  @curr_http_version = HTTPVersion
  @no_keepalive_server = false
  @close_on_empty_response = false
  @socket  = nil
  @started = false
  @open_timeout = nil
  @read_timeout = 60
  @continue_timeout = nil
  @debug_output = nil
  @use_ssl = false
  @ssl_context = nil
  @enable_post_connection_check = true
  @compression = nil
  @sspi_enabled = false
  if defined?(SSL_ATTRIBUTES)
    SSL_ATTRIBUTES.each do |name|
      instance_variable_set "@#{name}", nil
    end
  end
end

# File ../ruby/lib/net/http.rb, line 478
def HTTP.post_form(url, params)
  req = Post.new(url.request_uri)
  req.form_data = params
  req.basic_auth url.user, url.password if url.user
  new(url.hostname, url.port).start {|http|
    http.request(req)
  }
end

# File ../ruby/lib/net/http.rb, line 540
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

# File ../ruby/lib/net/http.rb, line 377
def HTTP.version_1_2
  true
end

# File ../ruby/lib/net/http.rb, line 383
def HTTP.version_1_2?
  true
end

# File ../ruby/lib/net/http.rb, line 647
def continue_timeout=(sec)
  @socket.continue_timeout = sec if @socket
  @continue_timeout = sec
end

# File ../ruby/lib/net/http.rb, line 1154
def copy(path, initheader = nil)
  request(Copy.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 1142
def delete(path, initheader = {'Depth' => 'Infinity'})
  request(Delete.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 820
def finish
  raise IOError, 'HTTP session not yet started' unless started?
  do_finish
end

# File ../ruby/lib/net/http.rb, line 1017
def get(path, initheader = {}, dest = nil, &block) # :yield: +body_segment+
  res = nil
  if HAVE_ZLIB
    unless  initheader.keys.any?{|k| k.downcase == "accept-encoding"}
      initheader = initheader.merge({
        "accept-encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
      })
      @compression = true
    end
  end
  request(Get.new(path, initheader)) {|r|
    if r.key?("content-encoding") and @compression
      @compression = nil # Clear it till next set.
      the_body = r.read_body dest, &block
      case r["content-encoding"]
      when "gzip"
        r.body= Zlib::GzipReader.new(StringIO.new(the_body), encoding: "ASCII-8BIT").read
        r.delete("content-encoding")
      when "deflate"
        r.body= Zlib::Inflate.inflate(the_body);
        r.delete("content-encoding")
      when "identity"
        ; # nothing needed
      else
        ; # Don't do anything dramatic, unless we need to later
      end
    else
      r.read_body dest, &block
    end
    res = r
  }
  res
end

# File ../ruby/lib/net/http.rb, line 1064
def head(path, initheader = nil)
  request(Head.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 599
def inspect
  "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
end

# File ../ruby/lib/net/http.rb, line 1118
def lock(path, body, initheader = nil)
  request(Lock.new(path, initheader), body)
end

# File ../ruby/lib/net/http.rb, line 1160
def mkcol(path, body = nil, initheader = nil)
  request(Mkcol.new(path, initheader), body)
end

# File ../ruby/lib/net/http.rb, line 1148
def move(path, initheader = nil)
  request(Move.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 1130
def options(path, initheader = nil)
  request(Options.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 1102
def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Patch, &block)
end

# File ../ruby/lib/net/http.rb, line 725
def peer_cert
  if not use_ssl? or not @socket
    return nil
  end
  @socket.io.peer_cert
end

# File ../ruby/lib/net/http.rb, line 1096
def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Post, &block)
end

# File ../ruby/lib/net/http.rb, line 1136
def propfind(path, body = nil, initheader = {'Depth' => '0'})
  request(Propfind.new(path, initheader), body)
end

# File ../ruby/lib/net/http.rb, line 1112
def proppatch(path, body, initheader = nil)
  request(Proppatch.new(path, initheader), body)
end

# File ../ruby/lib/net/http.rb, line 917
def proxy?
  self.class.proxy_class?
end

# File ../ruby/lib/net/http.rb, line 922
def proxy_address
  self.class.proxy_address
end

# File ../ruby/lib/net/http.rb, line 898
def proxy_class?
  @is_proxy_class
end

# File ../ruby/lib/net/http.rb, line 937
def proxy_pass
  self.class.proxy_pass
end

# File ../ruby/lib/net/http.rb, line 927
def proxy_port
  self.class.proxy_port
end

# File ../ruby/lib/net/http.rb, line 932
def proxy_user
  self.class.proxy_user
end

# File ../ruby/lib/net/http.rb, line 636
def read_timeout=(sec)
  @socket.read_timeout = sec if @socket
  @read_timeout = sec
end

# File ../ruby/lib/net/http.rb, line 1283
def request(req, body = nil, &block)  # :yield: +response+
  unless started?
    start {
      req['connection'] ||= 'close'
      return request(req, body, &block)
    }
  end
  if proxy_user()
    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

# File ../ruby/lib/net/http.rb, line 1195
def request_get(path, initheader = nil, &block) # :yield: +response+
  request(Get.new(path, initheader), &block)
end

# File ../ruby/lib/net/http.rb, line 1209
def request_head(path, initheader = nil, &block)
  request(Head.new(path, initheader), &block)
end

# File ../ruby/lib/net/http.rb, line 1239
def request_post(path, data, initheader = nil, &block) # :yield: +response+
  request Post.new(path, initheader), data, &block
end

# File ../ruby/lib/net/http.rb, line 1263
def send_request(name, path, data = nil, header = nil)
  r = HTTPGenericRequest.new(name,(data ? true : false),true,path,header)
  request r, data
end

# File ../ruby/lib/net/http.rb, line 612
def set_debug_output(output)
  warn 'Net::HTTP#set_debug_output called after HTTP started' if started?
  @debug_output = output
end

# File ../ruby/lib/net/http.rb, line 741
def start  # :yield: http
  raise IOError, 'HTTP session already opened' if @started
  if block_given?
    begin
      do_start
      return yield(self)
    ensure
      do_finish
    end
  end
  do_start
  self
end

# File ../ruby/lib/net/http.rb, line 653
def started?
  @started
end

# File ../ruby/lib/net/http.rb, line 1166
def trace(path, initheader = nil)
  request(Trace.new(path, initheader))
end

# File ../ruby/lib/net/http.rb, line 1124
def unlock(path, body, initheader = nil)
  request(Unlock.new(path, initheader), body)
end

# File ../ruby/lib/net/http.rb, line 670
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

# File ../ruby/lib/net/http.rb, line 662
def use_ssl?
  @use_ssl
end

# File ../ruby/lib/net/http.rb, line 1409
def D(msg)
  return unless @debug_output
  @debug_output << msg
  @debug_output << "\n"
end

# File ../ruby/lib/net/http.rb, line 1401
def addr_port
  if use_ssl?
    address() + (port == HTTP.https_default_port ? '' : ":#{port()}")
  else
    address() + (port == HTTP.http_default_port ? '' : ":#{port()}")
  end
end

# File ../ruby/lib/net/http.rb, line 1335
def begin_transport(req)
  connect if @socket.closed?
  if not req.response_body_permitted? and @close_on_empty_response
    req['connection'] ||= 'close'
  end
  req['host'] ||= addr_port()
end

# File ../ruby/lib/net/http.rb, line 948
def conn_address
  address()
end

# File ../ruby/lib/net/http.rb, line 952
def conn_port
  port()
end

# File ../ruby/lib/net/http.rb, line 761
def connect
  D "opening connection to #{conn_address()}..."
  s = timeout(@open_timeout) { TCPSocket.open(conn_address(), conn_port()) }
  D "opened"
  if use_ssl?
    ssl_parameters = Hash.new
    iv_list = instance_variables
    SSL_ATTRIBUTES.each do |name|
      ivname = "@#{name}".intern
      if iv_list.include?(ivname) and
         value = instance_variable_get(ivname)
        ssl_parameters[name] = value
      end
    end
    @ssl_context = OpenSSL::SSL::SSLContext.new
    @ssl_context.set_params(ssl_parameters)
    s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
    s.sync_close = true
  end
  @socket = BufferedIO.new(s)
  @socket.read_timeout = @read_timeout
  @socket.continue_timeout = @continue_timeout
  @socket.debug_output = @debug_output
  if use_ssl?
    begin
      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}"
        end
        @socket.writeline ''
        HTTPResponse.read_new(@socket).value
      end
      # Server Name Indication (SNI) RFC 3546
      s.hostname = @address if s.respond_to? :hostname=
      timeout(@open_timeout) { s.connect }
      if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
        s.post_connection_check(@address)
      end
    rescue => exception
      D "Conn close because of connect error #{exception}"
      @socket.close if @socket and not @socket.closed?
      raise exception
    end
  end
  on_connect
end

# File ../ruby/lib/net/http.rb, line 825
def do_finish
  @started = false
  @socket.close if @socket and not @socket.closed?
  @socket = nil
end

# File ../ruby/lib/net/http.rb, line 755
def do_start
  connect
  @started = true
end

# File ../ruby/lib/net/http.rb, line 956
def edit_path(path)
  path
end

# File ../ruby/lib/net/http.rb, line 1343
def end_transport(req, res)
  @curr_http_version = res.http_version
  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'
  else
    D 'Conn close'
    @socket.close
  end
end

# File ../ruby/lib/net/http.rb, line 1358
def keep_alive?(req, res)
  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

# File ../ruby/lib/net/http.rb, line 814
def on_connect
end

# File ../ruby/lib/net/http.rb, line 1306
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

# File ../ruby/lib/net/http.rb, line 1382
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

# File ../ruby/lib/net/http.rb, line 1367
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

# File ../ruby/lib/net/http.rb, line 1315
def transport_request(req)
  begin_transport req
  res = catch(:response) {
    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
  }
  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