http2 0.0.28 → 0.0.33

data/lib/http2/response.rb

@@ -0,0 +1,109 @@
+# This object will be returned as the response for each request.
+class Http2::Response
+  # All the data the response contains. Headers, body, cookies, requested URL and more.
+  attr_reader :headers, :request, :request_args, :requested_url
+  attr_accessor :body, :charset, :code, :http_version
+  attr_writer :content_type
+
+  # This method should not be called manually.
+  def initialize(body: "", debug: false, headers: {}, request:)
+    @body = body
+    @debug = debug
+    @headers = headers
+    @request = request
+    @requested_url = request.path
+  end
+
+  # Returns a certain header by name or false if not found.
+  #===Examples
+  # val = res.header("content-type")
+  def header(key)
+    return false unless headers.key?(key)
+
+    headers.fetch(key).first.to_s
+  end
+
+  # Returns true if a header of the given string exists.
+  #===Examples
+  # print "No content-type was given." if !http.header?("content-type")
+  def header?(key)
+    return true if headers.key?(key) && !headers[key].first.to_s.empty?
+
+    false
+  end
+
+  def content_length
+    if header?("content-length")
+      header("content-length").to_i
+    elsif @body
+      @body.bytesize
+    else
+      raise "Couldn't calculate content-length."
+    end
+  end
+
+  def content_type
+    if header?("content-type")
+      header("content-type")
+    else
+      raise "No content-type was given."
+    end
+  end
+
+  # Checks the data that has been sat on the object and raises various exceptions, if it does not validate somehow.
+  def validate!
+    puts "Http2: Validating response length." if @debug
+    validate_body_versus_content_length!
+  end
+
+  # Returns true if the result is JSON.
+  def json?
+    content_type == "application/json"
+  end
+
+  def json
+    @json ||= JSON.parse(body)
+  end
+
+  def host
+    @request.http2.host
+  end
+
+  def port
+    @request.http2.port
+  end
+
+  def ssl?
+    @request.http2.ssl?
+  end
+
+  def path
+    @request.path
+  end
+
+  def to_s
+    "#<Http::Response host=\"#{host}\" port=#{port} ssl=#{ssl?} path=\"#{path}\">"
+  end
+
+  def inspect
+    to_s
+  end
+
+private
+
+  # Checks that the length of the body is the same as the given content-length if given.
+  def validate_body_versus_content_length!
+    unless header?("content-length")
+      puts "Http2: No content length given - skipping length validation." if @debug
+      return nil
+    end
+
+    content_length = header("content-length").to_i
+    body_length = @body.bytesize
+
+    puts "Http2: Body length: #{body_length}" if @debug
+    puts "Http2: Content length: #{content_length}" if @debug
+
+    raise "Body does not match the given content-length: '#{body_length}', '#{content_length}'." if body_length != content_length
+  end
+end

data/{include → lib/http2}/response_reader.rb

@@ -1,17 +1,21 @@
 class Http2::ResponseReader
   attr_reader :response
 
-  def initialize(args)
+  def initialize(args:, http2:, sock:, request:)
     @mode = "headers"
     @transfer_encoding = nil
-    @response = Http2::Response.new(:request_args => args, :debug => @debug)
+    @request = request
+    @response = Http2::Response.new(debug: http2.debug, request: request)
     @rec_count = 0
-    @args, @debug, @http2, @sock = args[:args], args[:http2].debug, args[:http2], args[:sock]
+    @args = args
+    @debug = http2.debug
+    @http2 = http2
+    @sock = sock
     @nl = @http2.nl
     @conn = @http2.connection
 
     read_headers
-    read_body if @length == nil || @length > 0
+    read_body if @length == nil || @length.positive?
     finish
   end
 
@@ -23,6 +27,7 @@ class Http2::ResponseReader
       if line == "\n" || line == "\r\n" || line == @nl
         puts "Http2: Changing mode to body!" if @debug
         raise "No headers was given at all? Possibly corrupt state after last request?" if @response.headers.empty?
+
         @mode = "body"
         @http2.on_content_call(@args, @nl)
         break
@@ -49,24 +54,20 @@ class Http2::ResponseReader
   end
 
   def finish
-    #Check if we should reconnect based on keep-alive-max.
-    if @keepalive_max == 1 || @connection == "close"
-      @conn.close unless @conn.closed?
-    end
+    # Check if we should reconnect based on keep-alive-max.
+    @conn.close if !@conn.closed? && (@keepalive_max == 1 || @connection == "close")
 
     # Validate that the response is as it should be.
     puts "Http2: Validating response." if @debug
 
-    if !@response.code
-      raise "No status-code was received from the server. Headers: '#{@response.headers}' Body: '#{resp.body}'."
-    end
+    raise "No status-code was received from the server. Headers: '#{@response.headers}' Body: '#{@response.body}'." unless @response.code
 
     @response.validate!
     check_and_decode
     @http2.autostate_register(@response) if @http2.args[:autostate]
     handle_errors
 
-    if response = check_and_follow_redirect
+    if (response = check_and_follow_redirect)
       @response = response
     end
   end
@@ -74,27 +75,49 @@ class Http2::ResponseReader
 private
 
   def check_and_follow_redirect
-    if (@response.code == "302" || @response.code == "307") && @response.header?("location") && @http2.args[:follow_redirects]
+    if redirect_response?
       url, args = url_and_args_from_location
 
-      if !args[:host] || args[:host] == @args[:host]
-        return @http2.get(url)
+      if redirect_using_same_connection?(args)
+        @http2.get(url)
       else
         ::Http2.new(args).get(url)
       end
     end
   end
 
+  REDIRECT_CODES = [301, 302, 303, 307, 308].freeze
+  def redirect_response?
+    REDIRECT_CODES.include?(response.code.to_i) && response.header?("location") && @http2.args[:follow_redirects]
+  end
+
+  def redirect_using_same_connection?(args)
+    if !args[:host] || args[:host] == @args[:host]
+      true
+    else
+      false
+    end
+  end
+
+  def url
+    @url ||= response.header("location")
+  end
+
   def url_and_args_from_location
-    uri = URI.parse(@response.header("location"))
+    uri = URI.parse(url)
+
     url = uri.path
-    url << "?#{uri.query}" if uri.query.to_s.length > 0
+    url << "?#{uri.query}" unless uri.query.to_s.empty?
+    url = url.gsub(/\A\//, "")
+
+    args = @http2.args
+      .reject { |k, _v| [:ssl, :port].include? k }
+      .merge(host: uri.host)
 
-    args = {host: uri.host}
     args[:ssl] = true if uri.scheme == "https"
     args[:port] = uri.port if uri.port
 
-    return [url, args]
+    [url, args]
   end
 
   def check_and_decode
@@ -109,8 +132,8 @@ private
 
       begin
         valid_string = ic.encode("UTF-8")
-      rescue
-        valid_string = untrusted_str.force_encoding("UTF-8").encode("UTF-8", :invalid => :replace, :replace => "").encode("UTF-8")
+      rescue StandardError
+        valid_string = untrusted_str.force_encoding("UTF-8").encode("UTF-8", invalid: :replace, replace: "").encode("UTF-8")
       end
 
       @response.body = valid_string
@@ -118,16 +141,21 @@ private
   end
 
   def handle_errors
-    return unless  @http2.raise_errors
+    return unless @http2.raise_errors
 
-    if @response.code == "500"
+    case @response.code
+    when "500"
       err = Http2::Errors::Internalserver.new("A internal server error occurred")
-    elsif @response.code == "403"
+    when "403"
       err = Http2::Errors::Noaccess.new("No access")
-    elsif @response.code == "400"
+    when "400"
       err = Http2::Errors::Badrequest.new("Bad request")
-    elsif @response.code == "404"
+    when "401"
+      err = Http2::Errors::Unauthorized.new("Unauthorized")
+    when "404"
       err = Http2::Errors::Notfound.new("Not found")
+    when "415"
+      err = Http2::Errors::UnsupportedMediaType.new("Unsupported media type")
     end
 
     if err
@@ -140,13 +168,19 @@ private
     if line
       @rec_count += line.length
     elsif !line && @rec_count <= 0
-      raise Errno::ECONNABORTED, "Server closed the connection before being able to read anything (KeepAliveMax: '#{@http2.keepalive_max}', Connection: '#{@connection}', PID: '#{Process.pid}')."
+      parts = [
+        "KeepAliveMax: '#{@http2.keepalive_max}'",
+        "Connection: '#{@connection}'",
+        "PID: '#{Process.pid}'"
+      ]
+
+      raise Errno::ECONNABORTED, "Server closed the connection before being able to read anything (#{parts.join(", ")})."
     end
   end
 
   def parse_cookie(cookie_line)
-    ::Http2::Utils.parse_set_cookies(cookie_line).each do |cookie_data|
-      @http2.cookies[cookie_data["name"]] = cookie_data
+    ::Http2::Utils.parse_set_cookies(cookie_line).each do |cookie|
+      @http2.cookies[cookie.name] = cookie
     end
   end
 
@@ -163,24 +197,24 @@ private
   end
 
   def parse_content_type(content_type_line)
-    if match_charset = content_type_line.match(/\s*;\s*charset=(.+)/i)
+    if (match_charset = content_type_line.match(/\s*;\s*charset=(.+)/i))
       @charset = match_charset[1].downcase
       @response.charset = @charset
       content_type_line.gsub!(match_charset[0], "")
     end
 
-    @response.content_type = @content_type_line
+    @response.content_type = content_type_line
   end
 
-  #Parse a header-line and saves it on the object.
+  # Parse a header-line and saves it on the object.
   #===Examples
   # http.parse_header("Content-Type: text/html\r\n")
   def parse_header(line)
-    if match = line.match(/^(.+?):\s*(.+)#{@nl}$/)
+    if (match = line.match(/^(.+?):\s*(.+)#{@nl}$/))
       key = match[1].downcase
       set_header_special_values(key, match[2])
       parse_normal_header(line, key, match[1], match[2])
-    elsif match = line.match(/^HTTP\/([\d\.]+)\s+(\d+)\s+(.+)$/)
+    elsif (match = line.match(/^HTTP\/([\d\.]+)\s+(\d+)\s+(.+)$/)) # rubocop:disable Style/RedundantRegexpEscape
       @response.code = match[2]
       @response.http_version = match[1]
       @http2.on_content_call(@args, line)
@@ -211,18 +245,16 @@ private
     @response.headers[key] = [] unless @response.headers.key?(key)
     @response.headers[key] << value
 
-    if key != "transfer-encoding" && key != "content-length" && key != "connection" && key != "keep-alive"
-      @http2.on_content_call(@args, line)
-    end
+    @http2.on_content_call(@args, line) if key != "transfer-encoding" && key != "content-length" && key != "connection" && key != "keep-alive"
   end
 
-  #Parses the body based on given headers and saves it to the result-object.
+  # Parses the body based on given headers and saves it to the result-object.
   # http.parse_body(str)
   def parse_body(line)
-    return :break if @length == 0
+    return :break if @length&.zero?
 
     if @transfer_encoding == "chunked"
-      return parse_body_chunked(line)
+      parse_body_chunked(line)
     else
       puts "Http2: Adding #{line.to_s.bytesize} to the body." if @debug
       @response.body << line
@@ -234,15 +266,16 @@ private
   def parse_body_chunked(line)
     len = line.strip.hex
 
-    if len > 0
+    if len.positive?
       read = @conn.read(len)
       return :break if read == "" || read == "\n" || read == "\r\n"
+
       @response.body << read
       @http2.on_content_call(@args, read)
     end
 
     nl = @conn.gets
-    if len == 0
+    if len.zero?
       if nl == "\n" || nl == "\r\n"
         return :break
       else

data/{include → lib/http2}/url_builder.rb

@@ -1,14 +1,14 @@
 class Http2::UrlBuilder
   attr_accessor :host, :port, :protocol, :path, :params
 
-  def initialize args = {}
+  def initialize
     @params = {}
   end
 
   def build_params
     url_params = ""
 
-    if !params.empty?
+    unless params.empty?
       first = true
 
       params.each do |key, val|
@@ -24,18 +24,18 @@ class Http2::UrlBuilder
       end
     end
 
-    return url_params
+    url_params
   end
 
   def build_path_and_params
-    url = "#{path}"
+    url = path.to_s
 
     if params?
       url << "?"
       url << build_params
     end
 
-    return url
+    url
   end
 
   def build
@@ -49,7 +49,7 @@ class Http2::UrlBuilder
 
     url << build_path_and_params
 
-    return url
+    url
   end
 
   def params?

data/lib/http2/utils.rb

@@ -0,0 +1,52 @@
+# This class holds various methods for encoding, decoding and parsing of HTTP-related stuff.
+class Http2::Utils
+  # URL-encodes a string.
+  def self.urlenc(string)
+    # Thanks to CGI framework
+    string.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/) do
+      "%#{Regexp.last_match(1).unpack("H2" * Regexp.last_match(1).bytesize).join("%").upcase}"
+    end.tr(" ", "+")
+  end
+
+  # URL-decodes a string.
+  def self.urldec(string)
+    # Thanks to CGI framework
+    string.to_s.tr("+", " ").gsub(/((?:%[0-9a-fA-F]{2})+)/) do
+      [Regexp.last_match(1).delete("%")].pack("H*")
+    end
+  end
+
+  # Parses a cookies-string and returns them in an array.
+  def self.parse_set_cookies(str)
+    str = str.to_s
+    return [] if str.empty?
+
+    cookie_start_regex = /^(.+?)=(.*?)(;\s*|$)/
+
+    match = str.match(cookie_start_regex)
+    raise "Could not match cookie: '#{str}'" unless match
+
+    str.gsub!(cookie_start_regex, "")
+
+    cookie_data = {
+      name: urldec(match[1].to_s),
+      value: urldec(match[2].to_s)
+    }
+
+    while (match = str.match(/(.+?)=(.*?)(;\s*|$)/))
+      str = str.gsub(match[0], "")
+      key = match[1].to_s.downcase
+      value = match[2].to_s
+
+      if key == "path" || key == "expires"
+        cookie_data[key.to_sym] = value
+      else
+        cookie_data[key] = value
+      end
+    end
+
+    cookie = Http2::Cookie.new(cookie_data)
+
+    [cookie]
+  end
+end