http-2 0.11.0 → 1.0.0

data/lib/http/2/{huffman.rb → header/huffman.rb}

@@ -1,4 +1,7 @@
-require_relative 'error'
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "../extensions"
 
 module HTTP2
   # Implementation of huffman encoding for HPACK
@@ -7,7 +10,10 @@ module HTTP2
   module Header
     # Huffman encoder/decoder
     class Huffman
+      using StringExtensions
+
       include Error
+      include PackingExtensions
 
       BITS_AT_ONCE = 4
       EOS = 256
@@ -20,8 +26,8 @@ module HTTP2
       # @return [String] binary string
       def encode(str)
         bitstring = str.each_byte.map { |chr| ENCODE_TABLE[chr] }.join
-        bitstring << '1' * ((8 - bitstring.size) % 8)
-        [bitstring].pack('B*')
+        bitstring << ("1" * ((8 - bitstring.size) % 8))
+        [bitstring].pack("B*")
       end
 
       # Decodes provided Huffman coded string.
@@ -30,12 +36,12 @@ module HTTP2
       # @return [String] binary string
       # @raise [CompressionError] when Huffman coded string is malformed
       def decode(buf)
-        emit = ''
+        emit = "".b
         state = 0 # start state
 
         mask = (1 << BITS_AT_ONCE) - 1
         buf.each_byte do |chr|
-          (8 / BITS_AT_ONCE - 1).downto(0) do |shift|
+          ((8 / BITS_AT_ONCE) - 1).downto(0) do |shift|
             branch = (chr >> (shift * BITS_AT_ONCE)) & mask
             # MACHINE[state] = [final, [transitions]]
             #  [final] unfinished bits so far are prefix of the EOS code.
@@ -43,15 +49,15 @@ module HTTP2
             #  [emit] character to be emitted on this transition, empty string, or EOS.
             #  [next] next state number.
             trans = MACHINE[state][branch]
-            fail CompressionError, 'Huffman decode error (EOS found)' if trans.first == EOS
+            raise CompressionError, "Huffman decode error (EOS found)" if trans.first == EOS
+
             emit << trans.first.chr if trans.first
             state = trans.last
           end
         end
         # Check whether partial input is correctly filled
-        unless state <= MAX_FINAL_STATE
-          fail CompressionError, 'Huffman decode error (EOS invalid)'
-        end
+        raise CompressionError, "Huffman decode error (EOS invalid)" unless state <= MAX_FINAL_STATE
+
         emit.force_encoding(Encoding::BINARY)
       end
 
@@ -153,23 +159,23 @@ module HTTP2
         [0x7fff0, 19],
         [0x1ffc, 13],
         [0x3ffc, 14],
-        [0x22,  6],
+        [0x22, 6],
         [0x7ffd, 15],
-        [0x3,  5],
-        [0x23,  6],
-        [0x4,  5],
-        [0x24,  6],
-        [0x5,  5],
+        [0x3, 5],
+        [0x23, 6],
+        [0x4, 5],
+        [0x24, 6],
+        [0x5, 5],
         [0x25,  6],
         [0x26,  6],
         [0x27,  6],
-        [0x6,  5],
+        [0x6, 5],
         [0x74,  7],
         [0x75,  7],
         [0x28,  6],
         [0x29,  6],
         [0x2a,  6],
-        [0x7,  5],
+        [0x7, 5],
         [0x2b,  6],
         [0x76,  7],
         [0x2c,  6],
@@ -314,10 +320,10 @@ module HTTP2
         [0x7ffffef, 27],
         [0x7fffff0, 27],
         [0x3ffffee, 26],
-        [0x3fffffff, 30],
+        [0x3fffffff, 30]
       ].each(&:freeze).freeze
 
-      ENCODE_TABLE = CODES.map { |c, l| [c].pack('N').unpack('B*').first[-l..-1] }.each(&:freeze).freeze
+      ENCODE_TABLE = CODES.map { |c, l| [c].pack("N").unpack1("B*")[-l..-1] }.each(&:freeze).freeze
     end
   end
 end

data/lib/http/2/{huffman_statemachine.rb → header/huffman_statemachine.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Machine generated Huffman decoder state machine.
 # DO NOT EDIT THIS FILE.
 

data/lib/http/2/header.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HTTP2
+  # Implementation of header compression for HTTP 2.0 (HPACK) format adapted
+  # to efficiently represent HTTP headers in the context of HTTP 2.0.
+  #
+  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
+  module Header
+    # Header representation as defined by the spec.
+    HEADREP = {
+      indexed: { prefix: 7, pattern: 0x80 },
+      incremental: { prefix: 6, pattern: 0x40 },
+      noindex: { prefix: 4, pattern: 0x00 },
+      neverindexed: { prefix: 4, pattern: 0x10 },
+      changetablesize: { prefix: 5, pattern: 0x20 }
+    }.each_value(&:freeze).freeze
+
+    # Predefined options set for Compressor
+    # http://mew.org/~kazu/material/2014-hpack.pdf
+    NAIVE    = { index: :never,  huffman: :never   }.freeze
+    LINEAR   = { index: :all,    huffman: :never   }.freeze
+    STATIC   = { index: :static, huffman: :never   }.freeze
+    SHORTER  = { index: :all,    huffman: :never   }.freeze
+    NAIVEH   = { index: :never,  huffman: :always  }.freeze
+    LINEARH  = { index: :all,    huffman: :always  }.freeze
+    STATICH  = { index: :static, huffman: :always  }.freeze
+    SHORTERH = { index: :all,    huffman: :shorter }.freeze
+  end
+end
+
+require "http/2/header/huffman"
+require "http/2/header/huffman_statemachine"
+require "http/2/header/encoding_context"
+require "http/2/header/compressor"
+require "http/2/header/decompressor"

data/lib/http/2/server.rb

@@ -1,4 +1,5 @@
-require 'base64'
+# frozen_string_literal: true
+
 module HTTP2
   # HTTP 2.0 server connection class that implements appropriate header
   # compression / decompression algorithms and stream management logic.
@@ -20,14 +21,19 @@ module HTTP2
   #     end
   #
   class Server < Connection
+    attr_reader :origin_set
+
     # Initialize new HTTP 2.0 server object.
-    def initialize(**settings)
+    def initialize(settings = {})
       @stream_id    = 2
       @state        = :waiting_magic
 
       @local_role   = :server
       @remote_role  = :client
 
+      @origin_set = []
+      @origins_sent = true
+
       super
     end
 
@@ -72,14 +78,17 @@ module HTTP2
       receive(CONNECTION_PREFACE_MAGIC)
 
       # Process received HTTP2-Settings payload
-      buf = HTTP2::Buffer.new Base64.urlsafe_decode64(settings.to_s)
-      header = @framer.common_header(
-        length: buf.bytesize,
-        type: :settings,
-        stream: 0,
-        flags: [],
+      buf = "".b
+      buf << Base64.urlsafe_decode64(settings.to_s)
+      @framer.common_header(
+        {
+          length: buf.bytesize,
+          type: :settings,
+          stream: 0,
+          flags: []
+        },
+        buffer: buf
       )
-      buf.prepend(header)
       receive(buf)
 
       # Activate stream (id: 1) with on HTTP/1.1 request parameters
@@ -87,16 +96,17 @@ module HTTP2
       emit(:stream, stream)
 
       headers_frame = {
-        type:       :headers,
-        stream:     1,
-        weight:     DEFAULT_WEIGHT,
+        type: :headers,
+        flags: [:end_headers],
+        stream: 1,
+        weight: DEFAULT_WEIGHT,
         dependency: 0,
-        exclusive:  false,
-        payload: headers,
+        exclusive: false,
+        payload: headers
       }
 
       if body.empty?
-        headers_frame.merge!(flags: [:end_stream])
+        headers_frame[:flags] << [:end_stream]
         stream << headers_frame
       else
         stream << headers_frame
@@ -110,24 +120,41 @@ module HTTP2
       @state = :waiting_magic
     end
 
+    def origin_set=(origins)
+      @origin_set = Array(origins).map(&:to_s)
+      @origins_sent = @origin_set.empty?
+    end
+
     private
 
+    def connection_settings(frame)
+      super
+      return unless frame[:flags].include?(:ack) && !@origins_sent
+
+      send(type: :origin, stream: 0, payload: @origin_set)
+    end
+
+    def verify_pseudo_headers(frame)
+      _verify_pseudo_headers(frame, REQUEST_MANDATORY_HEADERS)
+    end
+
     # Handle locally initiated server-push event emitted by the stream.
     #
-    # @param args [Array]
+    # @param parent [Stream]
+    # @param headers [Enumerable[String, String]]
+    # @param flags [Array[Symbol]]
     # @param callback [Proc]
-    def promise(*args, &callback)
-      parent, headers, flags = *args
+    def promise(parent, headers, flags)
       promise = new_stream(parent: parent)
       promise.send(
         type: :push_promise,
         flags: flags,
         stream: parent.id,
         promise_stream: promise.id,
-        payload: headers.to_a,
+        payload: headers.to_a
       )
 
-      callback.call(promise)
+      yield(promise)
     end
   end
 end

data/lib/http/2/stream.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTP2
   # A single HTTP 2.0 connection can multiplex multiple streams in parallel:
   # multiple requests and responses can be in flight simultaneously and stream
@@ -49,11 +51,10 @@ module HTTP2
 
     # Stream priority as set by initiator.
     attr_reader :weight
-    attr_reader :dependency
+    attr_reader :dependency, :remote_window
 
     # Size of current stream flow control window.
     attr_reader :local_window
-    attr_reader :remote_window
     alias window local_window
 
     # Reason why connection was closed.
@@ -73,19 +74,24 @@ module HTTP2
     # @param parent [Stream]
     # @param state [Symbol]
     def initialize(connection:, id:, weight: 16, dependency: 0, exclusive: false, parent: nil, state: :idle)
+      stream_error(:protocol_error, msg: "stream can't depend on itself") if id == dependency
+
       @connection = connection
       @id = id
       @weight = weight
       @dependency = dependency
-      process_priority(weight: weight, stream_dependency: dependency, exclusive: exclusive)
+      process_priority(weight: weight, dependency: dependency, exclusive: exclusive)
       @local_window_max_size = connection.local_settings[:settings_initial_window_size]
-      @local_window  = connection.local_settings[:settings_initial_window_size]
+      @local_window = connection.local_settings[:settings_initial_window_size]
       @remote_window = connection.remote_settings[:settings_initial_window_size]
       @parent = parent
       @state  = state
       @error  = false
       @closed = false
-      @send_buffer = []
+      @_method = @_content_length = @_status_code = nil
+      @_waiting_on_trailers = false
+      @received_data = false
+      @activated = false
 
       on(:window) { |v| @remote_window = v }
       on(:local_window) { |v| @local_window_max_size = @local_window = v }
@@ -103,26 +109,52 @@ module HTTP2
 
       case frame[:type]
       when :data
+        # 6.1. DATA
+        # If a DATA frame is received whose stream is not in "open" or
+        # "half closed (local)" state, the recipient MUST respond with a
+        # stream error (Section 5.4.2) of type STREAM_CLOSED.
+        stream_error(:stream_closed) unless @state == :open ||
+                                            @state == :half_closed_local ||
+                                            @state == :half_closing || @state == :closing ||
+                                            (@state == :closed && @closed == :local_rst)
+        @received_data = true
+        calculate_content_length(frame[:length])
         update_local_window(frame)
         # Emit DATA frame
         emit(:data, frame[:payload]) unless frame[:ignore]
         calculate_window_update(@local_window_max_size)
       when :headers
+        stream_error(:stream_closed) if (@state == :closed && @closed != :local_rst) ||
+                                        @state == :remote_closed
+        @_method ||= frame[:method]
+        @_status_code ||= frame[:status]
+        @_content_length ||= frame[:content_length]
+        @_trailers ||= frame[:trailer]
+        if @_waiting_on_trailers ||
+           (@received_data &&
+               (!@_status_code || @_status_code >= 200))
+
+          # An endpoint that receives a HEADERS frame without the END_STREAM flag set after receiving a final
+          # (non-informational) status code MUST treat the corresponding request or response as malformed.
+          verify_trailers(frame)
+        end
         emit(:headers, frame[:payload]) unless frame[:ignore]
+        @_waiting_on_trailers = !@_trailers.nil?
       when :push_promise
         emit(:promise_headers, frame[:payload]) unless frame[:ignore]
+      when :continuation
+        stream_error(:stream_closed) if (@state == :closed && @closed != :local_rst) || @state == :remote_closed
+        stream_error(:protocol_error) if @received_data
       when :priority
         process_priority(frame)
       when :window_update
-        process_window_update(frame)
+        process_window_update(frame: frame)
       when :altsvc
         # 4.  The ALTSVC HTTP/2 Frame
         # An ALTSVC frame on a
         # stream other than stream 0 containing non-empty "Origin" information
         # is invalid and MUST be ignored.
-        if !frame[:origin] || frame[:origin].empty?
-          emit(frame[:type], frame)
-        end
+        emit(frame[:type], frame) if !frame[:origin] || frame[:origin].empty?
       when :blocked
         emit(frame[:type], frame)
       end
@@ -131,6 +163,29 @@ module HTTP2
     end
     alias << receive
 
+    def verify_trailers(frame)
+      stream_error(:protocol_error, msg: "trailer headers frame must close the stream") unless end_stream?(frame)
+      return unless @_trailers
+
+      trailers = frame[:payload]
+      return unless trailers.respond_to?(:each)
+
+      trailers.each do |field, _| # rubocop:disable Style/HashEachMethods
+        @_trailers.delete(field)
+        break if @_trailers.empty?
+      end
+      stream_error(:protocol_error, msg: "didn't receive all expected trailer headers") unless @_trailers.empty?
+    end
+
+    def calculate_content_length(data_length)
+      return unless @_content_length && data_length
+
+      @_content_length -= data_length
+      return if @_content_length >= 0
+
+      stream_error(:protocol_error, msg: "received more data than what was defined in content-length")
+    end
+
     # Processes outgoing HTTP 2.0 frames. Data frames may be automatically
     # split and buffered based on maximum frame size and current stream flow
     # control window size.
@@ -164,13 +219,13 @@ module HTTP2
     def headers(headers, end_headers: true, end_stream: false)
       flags = []
       flags << :end_headers if end_headers
-      flags << :end_stream  if end_stream
+      flags << :end_stream  if end_stream || @_method == "HEAD"
 
       send(type: :headers, flags: flags, payload: headers)
     end
 
     def promise(headers, end_headers: true, &block)
-      fail ArgumentError, 'must provide callback' unless block_given?
+      raise ArgumentError, "must provide callback" unless block
 
       flags = end_headers ? [:end_headers] : []
       emit(:promise, self, headers, flags, &block)
@@ -183,7 +238,7 @@ module HTTP2
     # @param dependency [Integer] new stream dependency stream
     def reprioritize(weight: 16, dependency: 0, exclusive: false)
       stream_error if @id.even?
-      send(type: :priority, weight: weight, stream_dependency: dependency, exclusive: exclusive)
+      send(type: :priority, weight: weight, dependency: dependency, exclusive: exclusive)
     end
 
     # Sends DATA frame containing response payload.
@@ -243,6 +298,7 @@ module HTTP2
     def window_update(increment)
       # emit stream-level WINDOW_UPDATE unless stream is closed
       return if @state == :closed || @state == :remote_closed
+
       send(type: :window_update, increment: increment)
     end
 
@@ -345,18 +401,18 @@ module HTTP2
       # connection error (Section 5.4.1) of type PROTOCOL_ERROR.
       when :reserved_local
         @state = if sending
-          case frame[:type]
-          when :headers     then event(:half_closed_remote)
-          when :rst_stream  then event(:local_rst)
-          else stream_error
-          end
-        else
-          case frame[:type]
-          when :rst_stream then event(:remote_rst)
-          when :priority, :window_update then @state
-          else stream_error
-          end
-        end
+                   case frame[:type]
+                   when :headers     then event(:half_closed_remote)
+                   when :rst_stream  then event(:local_rst)
+                   else stream_error
+                   end
+                 else
+                   case frame[:type]
+                   when :rst_stream then event(:remote_rst)
+                   when :priority, :window_update then @state
+                   else stream_error
+                   end
+                 end
 
       # A stream in the "reserved (remote)" state has been reserved by a
       # remote peer.
@@ -374,18 +430,18 @@ module HTTP2
       # error (Section 5.4.1) of type PROTOCOL_ERROR.
       when :reserved_remote
         @state = if sending
-          case frame[:type]
-          when :rst_stream then event(:local_rst)
-          when :priority, :window_update then @state
-          else stream_error
-          end
-        else
-          case frame[:type]
-          when :headers then event(:half_closed_local)
-          when :rst_stream then event(:remote_rst)
-          else stream_error
-          end
-        end
+                   case frame[:type]
+                   when :rst_stream then event(:local_rst)
+                   when :priority, :window_update then @state
+                   else stream_error
+                   end
+                 else
+                   case frame[:type]
+                   when :headers then event(:half_closed_local)
+                   when :rst_stream then event(:remote_rst)
+                   else stream_error
+                   end
+                 end
 
       # A stream in the "open" state may be used by both peers to send
       # frames of any type.  In this state, sending peers observe
@@ -523,26 +579,24 @@ module HTTP2
       when :closed
         if sending
           case frame[:type]
-          when :rst_stream then # ignore
-          when :priority   then
+          when :rst_stream # ignore
+          when :priority
             process_priority(frame)
           else
-            stream_error(:stream_closed) unless (frame[:type] == :rst_stream)
+            stream_error(:stream_closed) unless frame[:type] == :rst_stream
           end
+        elsif frame[:type] == :priority
+          process_priority(frame)
         else
-          if frame[:type] == :priority
-            process_priority(frame)
-          else
-            case @closed
-            when :remote_rst, :remote_closed
-              case frame[:type]
-              when :rst_stream, :window_update # nop here
-              else
-                stream_error(:stream_closed)
-              end
-            when :local_rst, :local_closed
-              frame[:ignore] = true if frame[:type] != :window_update
+          case @closed
+          when :remote_rst, :remote_closed
+            case frame[:type]
+            when :rst_stream, :window_update # nop here
+            else
+              stream_error(:stream_closed)
             end
+          when :local_rst, :local_closed
+            frame[:ignore] = true if frame[:type] != :window_update
           end
         end
       end
@@ -552,7 +606,7 @@ module HTTP2
       case newstate
       when :open
         @state = newstate
-        emit(:active)
+        activate_stream_in_conn
 
       when :reserved_local, :reserved_remote
         @state = newstate
@@ -560,7 +614,7 @@ module HTTP2
 
       when :half_closed_local, :half_closed_remote
         @closed = newstate
-        emit(:active) unless @state == :open
+        activate_stream_in_conn unless @state == :open
         @state = :half_closing
 
       when :local_closed, :remote_closed, :local_rst, :remote_rst
@@ -571,11 +625,25 @@ module HTTP2
       @state
     end
 
+    # Streams that are in the "open" state, or either of the "half closed"
+    # states count toward the maximum number of streams that an endpoint is
+    # permitted to open.
+    def activate_stream_in_conn
+      @connection.active_stream_count += 1
+      @activated = true
+      emit(:active)
+    end
+
+    def close_stream_in_conn(*args)
+      @connection.active_stream_count -= 1 if @activated
+      emit(:close, *args)
+    end
+
     def complete_transition(frame)
       case @state
       when :closing
         @state = :closed
-        emit(:close, frame[:error])
+        close_stream_in_conn(frame[:error])
       when :half_closing
         @state = @closed
         emit(:half_close)
@@ -584,12 +652,12 @@ module HTTP2
 
     def process_priority(frame)
       @weight = frame[:weight]
-      @dependency = frame[:stream_dependency]
+      @dependency = frame[:dependency]
       emit(
         :priority,
-        weight:     frame[:weight],
-        dependency: frame[:stream_dependency],
-        exclusive:  frame[:exclusive],
+        weight: frame[:weight],
+        dependency: frame[:dependency],
+        exclusive: frame[:exclusive]
       )
       # TODO: implement dependency tree housekeeping
       #   Latest draft defines a fairly complex priority control.
@@ -601,17 +669,18 @@ module HTTP2
     def end_stream?(frame)
       case frame[:type]
       when :data, :headers, :continuation
-        frame[:flags].include?(:end_stream)
+        frame[:flags] && frame[:flags].include?(:end_stream)
       else false
       end
     end
 
     def stream_error(error = :internal_error, msg: nil)
+      # if the stream already broke with an error, ignore subsequent
+
       @error = error
       close(error) if @state != :closed
 
-      klass = error.to_s.split('_').map(&:capitalize).join
-      fail Error.const_get(klass), msg
+      raise Error.types[error], msg
     end
     alias error stream_error
 

data/lib/http/2/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTP2
-  VERSION = '0.11.0'.freeze
+  VERSION = "1.0.0"
 end

data/lib/http/2.rb

@@ -1,13 +1,14 @@
-require 'http/2/version'
-require 'http/2/error'
-require 'http/2/emitter'
-require 'http/2/buffer'
-require 'http/2/flow_buffer'
-require 'http/2/huffman'
-require 'http/2/huffman_statemachine'
-require 'http/2/compressor'
-require 'http/2/framer'
-require 'http/2/connection'
-require 'http/2/client'
-require 'http/2/server'
-require 'http/2/stream'
+# frozen_string_literal: true
+
+require "http/2/version"
+require "http/2/extensions"
+require "http/2/base64"
+require "http/2/error"
+require "http/2/emitter"
+require "http/2/flow_buffer"
+require "http/2/header"
+require "http/2/framer"
+require "http/2/connection"
+require "http/2/client"
+require "http/2/server"
+require "http/2/stream"

data/sig/client.rbs

@@ -0,0 +1,9 @@
+module HTTP2
+  class Client < Connection
+    def upgrade: () -> Stream
+
+    def send_connection_preface: () -> void
+
+    def self.settings_header: (settings_enum) -> String
+  end
+end