# File net/http.rb, line 994
def HTTP.Proxy(p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil)
  return self unless p_addr

  Class.new(self) {
    @is_proxy_class = true

    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
  }
end
            

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

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

 
               # File net/http.rb, line 436
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 net/http.rb, line 471
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
    start(uri.hostname, uri.port,
          :use_ssl => uri.scheme == 'https') {|http|
      return http.request_get(uri, &block)
    }
  end
end
            

 
               # File net/http.rb, line 524
def HTTP.http_default_port
  80
end
            

 
               # File net/http.rb, line 529
def HTTP.https_default_port
  443
end
            

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

  http
end
            

 
               # File net/http.rb, line 634
def initialize(address, port = nil)
  @address = address
  @port    = (port || HTTP.default_port)
  @local_host = nil
  @local_port = nil
  @curr_http_version = HTTPVersion
  @keep_alive_timeout = 2
  @last_communicated = nil
  @close_on_empty_response = false
  @socket  = nil
  @started = false
  @open_timeout = 60
  @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
  @sspi_enabled = false
  SSL_IVNAMES.each do |ivname|
    instance_variable_set ivname, nil
  end
end
            

 
               # File net/http.rb, line 504
def HTTP.post_form(url, params)
  req = Post.new(url)
  req.form_data = params
  req.basic_auth url.user, url.password if url.user
  start(url.hostname, url.port,
        :use_ssl => url.scheme == 'https' ) {|http|
    http.request(req)
  }
end
            

 
               # File net/http.rb, line 1017
def proxy_class?
  defined?(@is_proxy_class) ? @is_proxy_class : false
end
            

 
               # File net/http.rb, line 567
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 net/http.rb, line 402
def HTTP.version_1_2
  true
end
            

 
               # File net/http.rb, line 408
def HTTP.version_1_2?
  true
end
            

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

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

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

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

 
               # File net/http.rb, line 1154
def get(path, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  res = nil
  request(Get.new(path, initheader)) {|r|
    r.read_body dest, &block
    res = r
  }
  res
end
            

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

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

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

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

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

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

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

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

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

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

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

 
               # File net/http.rb, line 1036
def proxy?
  !!if @proxy_from_env then
    proxy_uri
  else
    @proxy_address
  end
end
            

 
               # File net/http.rb, line 1057
def proxy_address
  if @proxy_from_env then
    proxy_uri&.hostname
  else
    @proxy_address
  end
end
            

 
               # File net/http.rb, line 1045
def proxy_from_env?
  @proxy_from_env
end
            

 
               # File net/http.rb, line 1080
def proxy_pass
  @proxy_pass
end
            

 
               # File net/http.rb, line 1066
def proxy_port
  if @proxy_from_env then
    proxy_uri&.port
  else
    @proxy_port
  end
end
            

 
               # File net/http.rb, line 1075
def proxy_user
  @proxy_user
end
            

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

 
               # File net/http.rb, line 1396
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 net/http.rb, line 1307
def request_get(path, initheader = nil, &block) # :yield: +response+
  request(Get.new(path, initheader), &block)
end
            

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

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

 
               # File net/http.rb, line 1375
def send_request(name, path, data = nil, header = nil)
  has_response_body = name != 'HEAD'
  r = HTTPGenericRequest.new(name,(data ? true : false),has_response_body,path,header)
  request r, data
end
            

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

 
               # File net/http.rb, line 848
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 net/http.rb, line 738
def started?
  @started
end
            

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

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

 
               # File net/http.rb, line 755
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 net/http.rb, line 747
def use_ssl?
  @use_ssl
end