Class: Net::HTTP

# File 'lib/net/http.rb', line 683

def initialize(address, port = nil)
  @address = address
  @port    = (port || HTTP.default_port)
  @ipaddr = nil
  @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
  @write_timeout = 60
  @continue_timeout = nil
  @max_retries = 1
  @debug_output = nil
  @response_body_encoding = false
  @ignore_eof = true

  @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 'lib/net/http.rb', line 429

alias is_version_1_2? version_1_2?   #:nodoc:

# File 'lib/net/http.rb', line 1175

attr_reader :proxy_address

# File 'lib/net/http.rb', line 1170

def proxy_class?
  defined?(@is_proxy_class) ? @is_proxy_class : false
end

# File 'lib/net/http.rb', line 1185

attr_reader :proxy_pass

# File 'lib/net/http.rb', line 1178

attr_reader :proxy_port

# File 'lib/net/http.rb', line 1181

attr_reader :proxy_user

# File 'lib/net/http.rb', line 423

def HTTP.version_1_1?  #:nodoc:
  false
end

# File 'lib/net/http.rb', line 413

def HTTP.version_1_2
  true
end

# File 'lib/net/http.rb', line 419

def HTTP.version_1_2?
  true
end

# File 'lib/net/http.rb', line 474

def HTTP.get(uri_or_host, path_or_headers = nil, port = nil)
  get_response(uri_or_host, path_or_headers, port).body
end

# File 'lib/net/http.rb', line 451

def HTTP.get_print(uri_or_host, path_or_headers = nil, port = nil)
  get_response(uri_or_host, path_or_headers, port) {|res|
    res.read_body do |chunk|
      $stdout.print chunk
    end
  }
  nil
end

# File 'lib/net/http.rb', line 494

def HTTP.get_response(uri_or_host, path_or_headers = nil, port = nil, &block)
  if path_or_headers && !path_or_headers.is_a?(Hash)
    host = uri_or_host
    path = path_or_headers
    new(host, port || HTTP.default_port).start {|http|
      return http.request_get(path, &block)
    }
  else
    uri = uri_or_host
    headers = path_or_headers
    start(uri.hostname, uri.port,
          :use_ssl => uri.scheme == 'https') {|http|
      return http.request_get(uri, headers, &block)
    }
  end
end

# File 'lib/net/http.rb', line 566

def HTTP.http_default_port
  80
end

# File 'lib/net/http.rb', line 571

def HTTP.https_default_port
  443
end

# File 'lib/net/http.rb', line 632

alias newobj new # :nodoc:

# File 'lib/net/http.rb', line 522

def HTTP.post(url, data, header = nil)
  start(url.hostname, url.port,
        :use_ssl => url.scheme == 'https' ) {|http|
    http.post(url, data, header)
  }
end

# File 'lib/net/http.rb', line 546

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 'lib/net/http.rb', line 1147

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 'lib/net/http.rb', line 575

def HTTP.socket_type   #:nodoc: obsolete
  BufferedIO
end

# File 'lib/net/http.rb', line 609

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
  p_addr = :ENV if arg.size < 2
  port = https_default_port if !port && opt && opt[:use_ssl]
  http = new(address, port, p_addr, p_port, p_user, p_pass)
  http.ipaddr = opt[:ipaddr] if opt && opt[:ipaddr]

  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 'lib/net/http.rb', line 739

attr_reader :address

# File 'lib/net/http.rb', line 911

attr_accessor :ca_file

# File 'lib/net/http.rb', line 915

attr_accessor :ca_path

# File 'lib/net/http.rb', line 919

attr_accessor :cert

# File 'lib/net/http.rb', line 922

attr_accessor :cert_store

# File 'lib/net/http.rb', line 925

attr_accessor :ciphers

# File 'lib/net/http.rb', line 854

attr_accessor :close_on_empty_response

# File 'lib/net/http.rb', line 829

attr_reader :continue_timeout

# File 'lib/net/http.rb', line 832

def continue_timeout=(sec)
  @socket.continue_timeout = sec if @socket
  @continue_timeout = sec
end

# File 'lib/net/http.rb', line 929

attr_accessor :extra_chain_cert

# File 'lib/net/http.rb', line 845

attr_accessor :ignore_eof

# File 'lib/net/http.rb', line 769

def ipaddr
  started? ?  @socket.io.peeraddr[3] : @ipaddr
end

# File 'lib/net/http.rb', line 774

def ipaddr=(addr)
  raise IOError, "ipaddr value changed, but session already started" if started?
  @ipaddr = addr
end

# File 'lib/net/http.rb', line 841

attr_accessor :keep_alive_timeout

# File 'lib/net/http.rb', line 933

attr_accessor :key

# File 'lib/net/http.rb', line 745

attr_accessor :local_host

# File 'lib/net/http.rb', line 748

attr_accessor :local_port

# File 'lib/net/http.rb', line 812

attr_reader :max_retries

# File 'lib/net/http.rb', line 804

def max_retries=(retries)
  retries = retries.to_int
  if retries < 0
    raise ArgumentError, 'max_retries should be non-negative integer number'
  end
  @max_retries = retries
end

# File 'lib/net/http.rb', line 945

attr_accessor :max_version

# File 'lib/net/http.rb', line 942

attr_accessor :min_version

# File 'lib/net/http.rb', line 783

attr_accessor :open_timeout

# File 'lib/net/http.rb', line 742

attr_reader :port

# File 'lib/net/http.rb', line 1189

def proxy?
  !!(@proxy_from_env ? proxy_uri : @proxy_address)
end

# File 'lib/net/http.rb', line 1208

def proxy_address
  if @proxy_from_env then
    proxy_uri&.hostname
  else
    @proxy_address
  end
end

# File 'lib/net/http.rb', line 763

attr_writer :proxy_address

# File 'lib/net/http.rb', line 762

attr_writer :proxy_from_env

# File 'lib/net/http.rb', line 1194

def proxy_from_env?
  @proxy_from_env
end

# File 'lib/net/http.rb', line 1236

def proxy_pass
  if @proxy_from_env
    pass = proxy_uri&.password
    unescape(pass) if pass
  else
    @proxy_pass
  end
end

# File 'lib/net/http.rb', line 766

attr_writer :proxy_pass

# File 'lib/net/http.rb', line 1217

def proxy_port
  if @proxy_from_env then
    proxy_uri&.port
  else
    @proxy_port
  end
end

# File 'lib/net/http.rb', line 764

attr_writer :proxy_port

# File 'lib/net/http.rb', line 1226

def proxy_user
  if @proxy_from_env
    user = proxy_uri&.user
    unescape(user) if user
  else
    @proxy_user
  end
end

# File 'lib/net/http.rb', line 765

attr_writer :proxy_user

# File 'lib/net/http.rb', line 1245

alias proxyaddr proxy_address   #:nodoc: obsolete

# File 'lib/net/http.rb', line 1246

alias proxyport proxy_port      #:nodoc: obsolete

# File 'lib/net/http.rb', line 789

attr_reader :read_timeout

# File 'lib/net/http.rb', line 815

def read_timeout=(sec)
  @socket.read_timeout = sec if @socket
  @read_timeout = sec
end

# File 'lib/net/http.rb', line 753

attr_reader :response_body_encoding

# File 'lib/net/http.rb', line 757

def response_body_encoding=(value)
  value = Encoding.find(value) if value.is_a?(String)
  @response_body_encoding = value
end

# File 'lib/net/http.rb', line 936

attr_accessor :ssl_timeout

# File 'lib/net/http.rb', line 939

attr_accessor :ssl_version

# File 'lib/net/http.rb', line 848

def started?
  @started
end

# File 'lib/net/http.rb', line 865

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 'lib/net/http.rb', line 857

def use_ssl?
  @use_ssl
end

# File 'lib/net/http.rb', line 948

attr_accessor :verify_callback

# File 'lib/net/http.rb', line 951

attr_accessor :verify_depth

# File 'lib/net/http.rb', line 961

attr_accessor :verify_hostname

# File 'lib/net/http.rb', line 957

attr_accessor :verify_mode

# File 'lib/net/http.rb', line 796

attr_reader :write_timeout

# File 'lib/net/http.rb', line 821

def write_timeout=(sec)
  @socket.write_timeout = sec if @socket
  @write_timeout = sec
end

# File 'lib/net/http.rb', line 1648

def begin_transport(req)
  if @socket.closed?
    connect
  elsif @last_communicated
    if @last_communicated + @keep_alive_timeout < Process.clock_gettime(Process::CLOCK_MONOTONIC)
      debug 'Conn close because of keep_alive_timeout'
      @socket.close
      connect
    elsif @socket.io.to_io.wait_readable(0) && @socket.eof?
      debug "Conn close because of EOF"
      @socket.close
      connect
    end
  end

  if not req.response_body_permitted? and @close_on_empty_response
    req['connection'] ||= 'close'
  end

  req.update_uri address, port, use_ssl?
  req['host'] ||= addr_port()
end

# File 'lib/net/http.rb', line 1257

def conn_address # :nodoc:
  @ipaddr || address()
end

# File 'lib/net/http.rb', line 1261

def conn_port # :nodoc:
  port()
end

# File 'lib/net/http.rb', line 1000

def connect
  if use_ssl?
    # reference early to load OpenSSL before connecting,
    # as OpenSSL may take time to load.
    @ssl_context = OpenSSL::SSL::SSLContext.new
  end

  if proxy? then
    conn_addr = proxy_address
    conn_port = proxy_port
  else
    conn_addr = conn_address
    conn_port = port
  end

  debug "opening connection to #{conn_addr}:#{conn_port}..."
  s = Timeout.timeout(@open_timeout, Net::OpenTimeout) {
    begin
      TCPSocket.open(conn_addr, conn_port, @local_host, @local_port)
    rescue => e
      raise e, "Failed to open TCP connection to " +
        "#{conn_addr}:#{conn_port} (#{e.message})"
    end
  }
  s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
  debug "opened"
  if use_ssl?
    if proxy?
      plain_sock = BufferedIO.new(s, read_timeout: @read_timeout,
                                  write_timeout: @write_timeout,
                                  continue_timeout: @continue_timeout,
                                  debug_output: @debug_output)
      buf = "CONNECT #{conn_address}:#{@port} HTTP/#{HTTPVersion}\r\n"
      buf << "Host: #{@address}:#{@port}\r\n"
      if proxy_user
        credential = ["#{proxy_user}:#{proxy_pass}"].pack('m0')
        buf << "Proxy-Authorization: Basic #{credential}\r\n"
      end
      buf << "\r\n"
      plain_sock.write(buf)
      HTTPResponse.read_new(plain_sock).value
      # assuming nothing left in buffers after successful CONNECT response
    end

    ssl_parameters = Hash.new
    iv_list = instance_variables
    SSL_IVNAMES.each_with_index do |ivname, i|
      if iv_list.include?(ivname)
        value = instance_variable_get(ivname)
        unless value.nil?
          ssl_parameters[SSL_ATTRIBUTES[i]] = value
        end
      end
    end
    @ssl_context.set_params(ssl_parameters)
    unless @ssl_context.session_cache_mode.nil? # a dummy method on JRuby
      @ssl_context.session_cache_mode =
          OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT |
              OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE
    end
    if @ssl_context.respond_to?(:session_new_cb) # not implemented under JRuby
      @ssl_context.session_new_cb = proc {|sock, sess| @ssl_session = sess }
    end

    # Still do the post_connection_check below even if connecting
    # to IP address
    verify_hostname = @ssl_context.verify_hostname

    # Server Name Indication (SNI) RFC 3546/6066
    case @address
    when Resolv::IPv4::Regex, Resolv::IPv6::Regex
      # don't set SNI, as IP addresses in SNI is not valid
      # per RFC 6066, section 3.

      # Avoid openssl warning
      @ssl_context.verify_hostname = false
    else
      ssl_host_address = @address
    end

    debug "starting SSL for #{conn_addr}:#{conn_port}..."
    s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
    s.sync_close = true
    s.hostname = ssl_host_address if s.respond_to?(:hostname=) && ssl_host_address

    if @ssl_session and
       Process.clock_gettime(Process::CLOCK_REALTIME) < @ssl_session.time.to_f + @ssl_session.timeout
      s.session = @ssl_session
    end
    ssl_socket_connect(s, @open_timeout)
    if (@ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE) && verify_hostname
      s.post_connection_check(@address)
    end
    debug "SSL established, protocol: #{s.ssl_version}, cipher: #{s.cipher[0]}"
  end
  @socket = BufferedIO.new(s, read_timeout: @read_timeout,
                           write_timeout: @write_timeout,
                           continue_timeout: @continue_timeout,
                           debug_output: @debug_output)
  @last_communicated = nil
  on_connect
rescue => exception
  if s
    debug "Conn close because of connect error #{exception}"
    s.close
  end
  raise
end

# File 'lib/net/http.rb', line 1432

def copy(path, initheader = nil)
  request(Copy.new(path, initheader))
end

# File 'lib/net/http.rb', line 1745

alias_method :D, :debug

# File 'lib/net/http.rb', line 1739

def debug(msg)
  return unless @debug_output
  @debug_output << msg
  @debug_output << "\n"
end

# File 'lib/net/http.rb', line 1420

def delete(path, initheader = {'Depth' => 'Infinity'})
  request(Delete.new(path, initheader))
end

# File 'lib/net/http.rb', line 1121

def do_finish
  @started = false
  @socket.close if @socket
  @socket = nil
end

# File 'lib/net/http.rb', line 994

def do_start
  connect
  @started = true
end

# File 'lib/net/http.rb', line 1265

def edit_path(path)
  if proxy?
    if path.start_with?("ftp://") || use_ssl?
      path
    else
      "http://#{addr_port}#{path}"
    end
  else
    path
  end
end

# File 'lib/net/http.rb', line 1671

def end_transport(req, res)
  @curr_http_version = res.http_version
  @last_communicated = nil
  if @socket.closed?
    debug 'Conn socket closed'
  elsif not res.body and @close_on_empty_response
    debug 'Conn close'
    @socket.close
  elsif keep_alive?(req, res)
    debug 'Conn keep-alive'
    @last_communicated = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  else
    debug 'Conn close'
    @socket.close
  end
end

# File 'lib/net/http.rb', line 1116

def finish
  raise IOError, 'HTTP session not yet started' unless started?
  do_finish
end

# File 'lib/net/http.rb', line 1320

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 'lib/net/http.rb', line 1525

alias get2   request_get    #:nodoc: obsolete

# File 'lib/net/http.rb', line 1342

def head(path, initheader = nil)
  request(Head.new(path, initheader))
end

# File 'lib/net/http.rb', line 1526

alias head2  request_head   #:nodoc: obsolete

# File 'lib/net/http.rb', line 720

def inspect
  "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
end

# File 'lib/net/http.rb', line 1688

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 'lib/net/http.rb', line 1396

def lock(path, body, initheader = nil)
  request(Lock.new(path, initheader), body)
end

# File 'lib/net/http.rb', line 1438

def mkcol(path, body = nil, initheader = nil)
  request(Mkcol.new(path, initheader), body)
end

# File 'lib/net/http.rb', line 1426

def move(path, initheader = nil)
  request(Move.new(path, initheader))
end

# File 'lib/net/http.rb', line 1110

def on_connect
end

# File 'lib/net/http.rb', line 1408

def options(path, initheader = nil)
  request(Options.new(path, initheader))
end

# File 'lib/net/http.rb', line 1380

def patch(path, data, initheader = nil, dest = nil, &block) # :yield: body_segment
  send_entity(path, data, initheader, dest, Patch, &block)
end

# File 'lib/net/http.rb', line 964

def peer_cert
  if not use_ssl? or not @socket
    return nil
  end
  @socket.io.peer_cert
end

# File 'lib/net/http.rb', line 1374

def post(path, data, initheader = nil, dest = nil, &block) # :yield: body_segment
  send_entity(path, data, initheader, dest, Post, &block)
end

# File 'lib/net/http.rb', line 1527

alias post2  request_post   #:nodoc: obsolete

# File 'lib/net/http.rb', line 1414

def propfind(path, body = nil, initheader = {'Depth' => '0'})
  request(Propfind.new(path, initheader), body)
end

# File 'lib/net/http.rb', line 1390

def proppatch(path, body, initheader = nil)
  request(Proppatch.new(path, initheader), body)
end

# File 'lib/net/http.rb', line 1199

def proxy_uri # :nodoc:
  return if @proxy_uri == false
  @proxy_uri ||= URI::HTTP.new(
    "http".freeze, nil, address, port, nil, nil, nil, nil, nil
  ).find_proxy || false
  @proxy_uri || nil
end

# File 'lib/net/http.rb', line 1384

def put(path, data, initheader = nil)   #:nodoc:
  request(Put.new(path, initheader), data)
end

# File 'lib/net/http.rb', line 1528

alias put2   request_put    #:nodoc: obsolete

# File 'lib/net/http.rb', line 1562

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 'lib/net/http.rb', line 1473

def request_get(path, initheader = nil, &block) # :yield: response
  request(Get.new(path, initheader), &block)
end

# File 'lib/net/http.rb', line 1487

def request_head(path, initheader = nil, &block)
  request(Head.new(path, initheader), &block)
end

# File 'lib/net/http.rb', line 1517

def request_post(path, data, initheader = nil, &block) # :yield: response
  request Post.new(path, initheader), data, &block
end

# File 'lib/net/http.rb', line 1521

def request_put(path, data, initheader = nil, &block)   #:nodoc:
  request Put.new(path, initheader), data, &block
end

# File 'lib/net/http.rb', line 1585

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