SkullCyberArmy Bypass Shell - chauffeursltd.com

Uname : Linux premium36.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Soft : LiteSpeed
Ip : 198.54.115.237
Port : 443

File Name : generic_request.rb

# HTTPGenericRequest is the parent of the HTTPRequest class.
# Do not use this directly; use a subclass of HTTPRequest.
#
# Mixes in the HTTPHeader module to provide easier access to HTTP headers.
#
class Net::HTTPGenericRequest

include Net::HTTPHeader

def initialize(m, reqbody, resbody, uri_or_path, initheader = nil)
    @method = m
    @request_has_body = reqbody
    @response_has_body = resbody

if URI === uri_or_path then
      @uri = uri_or_path.dup
      host = @uri.hostname
      host += ":#{@uri.port}" if @uri.port != @uri.class::DEFAULT_PORT
      path = uri_or_path.request_uri
    else
      @uri = nil
      host = nil
      path = uri_or_path
    end

raise ArgumentError, "no HTTP request path given" unless path
    raise ArgumentError, "HTTP request path is empty" if path.empty?
    @path = path

@decode_content = false

if @response_has_body and Net::HTTP::HAVE_ZLIB then
      if !initheader ||
         !initheader.keys.any? { |k|
           %w[accept-encoding range].include? k.downcase
         } then
        @decode_content = true
        initheader = initheader ? initheader.dup : {}
        initheader["accept-encoding"] =
          "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
      end
    end

initialize_http_header initheader
    self['Accept'] ||= '*/*'
    self['User-Agent'] ||= 'Ruby'
    self['Host'] ||= host
    @body = nil
    @body_stream = nil
    @body_data = nil
  end

attr_reader :method
  attr_reader :path
  attr_reader :uri

# Automatically set to false if the user sets the Accept-Encoding header.
  # This indicates they wish to handle Content-encoding in responses
  # themselves.
  attr_reader :decode_content

def inspect
    "\#<#{self.class} #{@method}>"
  end

##
  # Don't automatically decode response content-encoding if the user indicates
  # they want to handle it.

def []=(key, val) # :nodoc:
    @decode_content = false if key.downcase == 'accept-encoding'

super key, val
  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
    @body_data = nil
    str
  end

attr_reader :body_stream

def body_stream=(input)
    @body = nil
    @body_stream = input
    @body_data = nil
    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
    if @body.nil? && @body_stream.nil? && @body_data.nil? && request_body_permitted?
      self.body = ''
    end
  end

#
  # write
  #

def exec(sock, ver, path)   #:nodoc: internal use only
    if @uri
      if @uri.port == @uri.default_port
        # [Bug #7650] Amazon ECS API and GFE/1.3 disallow extra default port number
        self['host'] = @uri.host
      else
        self['host'] = "#{@uri.host}:#{@uri.port}"
      end
    end

if @body
      send_request_with_body sock, ver, path, @body
    elsif @body_stream
      send_request_with_body_stream sock, ver, path, @body_stream
    elsif @body_data
      send_request_with_body_data sock, ver, path, @body_data
    else
      write_header sock, ver, path
    end
  end

def update_uri(host, port, ssl) # :nodoc: internal use only
    return unless @uri

@uri.host ||= host
    @uri.port = port

scheme = ssl ? 'https' : 'http'

# convert the class of the URI
    unless scheme == @uri.scheme then
      new_uri = @uri.to_s.sub(/^https?/, scheme)
      @uri = URI new_uri
    end

@uri
  end

private

class Chunker #:nodoc:
    def initialize(sock)
      @sock = sock
      @prev = nil
    end

def write(buf)
      # avoid memcpy() of buf, buf can huge and eat memory bandwidth
      @sock.write("#{buf.bytesize.to_s(16)}\r\n")
      rv = @sock.write(buf)
      @sock.write("\r\n")
      rv
    end

def finish
      @sock.write("0\r\n\r\n")
    end
  end

def send_request_with_body(sock, ver, path, body)
    self.content_length = body.bytesize
    delete 'Transfer-Encoding'
    supply_default_content_type
    write_header sock, ver, path
    wait_for_continue sock, ver if sock.continue_timeout
    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
    wait_for_continue sock, ver if sock.continue_timeout
    if chunked?
      chunker = Chunker.new(sock)
      IO.copy_stream(f, chunker)
      chunker.finish
    else
      # copy_stream can sendfile() to sock.io unless we use SSL.
      # If sock.io is an SSLSocket, copy_stream will hit SSL_write()
      IO.copy_stream(f, sock.io)
    end
  end

def send_request_with_body_data(sock, ver, path, params)
    if /\Amultipart\/form-data\z/i !~ self.content_type
      self.content_type = 'application/x-www-form-urlencoded'
      return send_request_with_body(sock, ver, path, URI.encode_www_form(params))
    end

opt = @form_option.dup
    require 'securerandom' unless defined?(SecureRandom)
    opt[:boundary] ||= SecureRandom.urlsafe_base64(40)
    self.set_content_type(self.content_type, boundary: opt[:boundary])
    if chunked?
      write_header sock, ver, path
      encode_multipart_form_data(sock, params, opt)
    else
      require 'tempfile'
      file = Tempfile.new('multipart')
      file.binmode
      encode_multipart_form_data(file, params, opt)
      file.rewind
      self.content_length = file.size
      write_header sock, ver, path
      IO.copy_stream(file, sock)
      file.close(true)
    end
  end

def encode_multipart_form_data(out, params, opt)
    charset = opt[:charset]
    boundary = opt[:boundary]
    require 'securerandom' unless defined?(SecureRandom)
    boundary ||= SecureRandom.urlsafe_base64(40)
    chunked_p = chunked?

buf = ''
    params.each do |key, value, h={}|
      key = quote_string(key, charset)
      filename =
        h.key?(:filename) ? h[:filename] :
        value.respond_to?(:to_path) ? File.basename(value.to_path) :
        nil

buf << "--#{boundary}\r\n"
      if filename
        filename = quote_string(filename, charset)
        type = h[:content_type] || 'application/octet-stream'
        buf << "Content-Disposition: form-data; " \
          "name=\"#{key}\"; filename=\"#{filename}\"\r\n" \
          "Content-Type: #{type}\r\n\r\n"
        if !out.respond_to?(:write) || !value.respond_to?(:read)
          # if +out+ is not an IO or +value+ is not an IO
          buf << (value.respond_to?(:read) ? value.read : value)
        elsif value.respond_to?(:size) && chunked_p
          # if +out+ is an IO and +value+ is a File, use IO.copy_stream
          flush_buffer(out, buf, chunked_p)
          out << "%x\r\n" % value.size if chunked_p
          IO.copy_stream(value, out)
          out << "\r\n" if chunked_p
        else
          # +out+ is an IO, and +value+ is not a File but an IO
          flush_buffer(out, buf, chunked_p)
          1 while flush_buffer(out, value.read(4096), chunked_p)
        end
      else
        # non-file field:
        #   HTML5 says, "The parts of the generated multipart/form-data
        #   resource that correspond to non-file fields must not have a
        #   Content-Type header specified."
        buf << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
        buf << (value.respond_to?(:read) ? value.read : value)
      end
      buf << "\r\n"
    end
    buf << "--#{boundary}--\r\n"
    flush_buffer(out, buf, chunked_p)
    out << "0\r\n\r\n" if chunked_p
  end

def quote_string(str, charset)
    str = str.encode(charset, fallback:->(c){'&#%d;'%c.encode("UTF-8").ord}) if charset
    str = str.gsub(/[\\"]/, '\\\\\&')
  end

def flush_buffer(out, buf, chunked_p)
    return unless buf
    out << "%x\r\n"%buf.bytesize if chunked_p
    out << buf
    out << "\r\n" if chunked_p
    buf.clear
  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

##
  # Waits up to the continue timeout for a response from the server provided
  # we're speaking HTTP 1.1 and are expecting a 100-continue response.

def wait_for_continue(sock, ver)
    if ver >= '1.1' and @header['expect'] and
        @header['expect'].include?('100-continue')
      if IO.select([sock.io], nil, nil, sock.continue_timeout)
        res = Net::HTTPResponse.read_new(sock)
        unless res.kind_of?(Net::HTTPContinue)
          res.decode_content = @decode_content
          throw :response, res
        end
      end
    end
  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

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2024-03-03 10:43:33
..	dir	-	0755	2024-03-03 10:43:33
backward.rb	text/x-ruby	578 B	0644	2012-08-23 10:42:12
exceptions.rb	text/x-ruby	710 B	0644	2012-05-22 08:36:21
generic_request.rb	text/x-ruby	9.04 KB	0644	2013-02-14 03:51:45
header.rb	text/x-ruby	14.36 KB	0644	2012-05-23 01:09:26
proxy_delta.rb	text/x-ruby	241 B	0644	2012-05-22 08:36:21
request.rb	text/x-ruby	715 B	0644	2012-07-19 10:43:38
requests.rb	text/x-ruby	2.88 KB	0644	2012-05-22 08:36:21
response.rb	text/x-ruby	9.78 KB	0644	2015-01-14 07:32:00
responses.rb	text/x-ruby	8.42 KB	0644	2012-07-05 03:31:31