http-2 0.12.0 → 1.0.0

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,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 module HTTP2
   # HTTP 2.0 server connection class that implements appropriate header
   # compression / decompression algorithms and stream management logic.
@@ -22,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
 
@@ -74,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
@@ -90,6 +97,7 @@ module HTTP2
 
       headers_frame = {
         type: :headers,
+        flags: [:end_headers],
         stream: 1,
         weight: DEFAULT_WEIGHT,
         dependency: 0,
@@ -98,7 +106,7 @@ module HTTP2
       }
 
       if body.empty?
-        headers_frame.merge!(flags: [:end_stream])
+        headers_frame[:flags] << [:end_stream]
         stream << headers_frame
       else
         stream << headers_frame
@@ -112,14 +120,31 @@ 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,
@@ -129,7 +154,7 @@ module HTTP2
         payload: headers.to_a
       )
 
-      callback.call(promise)
+      yield(promise)
     end
   end
 end

data/lib/http/2/stream.rb

@@ -74,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 }
@@ -104,18 +109,46 @@ 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
@@ -130,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.
@@ -163,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)
-      raise 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)
@@ -182,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.
@@ -550,7 +606,7 @@ module HTTP2
       case newstate
       when :open
         @state = newstate
-        emit(:active)
+        activate_stream_in_conn
 
       when :reserved_local, :reserved_remote
         @state = newstate
@@ -558,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
@@ -569,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)
@@ -582,11 +652,11 @@ 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],
+        dependency: frame[:dependency],
         exclusive: frame[:exclusive]
       )
       # TODO: implement dependency tree housekeeping
@@ -599,19 +669,18 @@ module HTTP2
     def end_stream?(frame)
       case frame[:type]
       when :data, :headers, :continuation
-        return false unless frame[:flags]
-
-        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
-      raise Error.const_get(klass), msg
+      raise Error.types[error], msg
     end
     alias error stream_error
 

data/lib/http/2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP2
-  VERSION = '0.12.0'
+  VERSION = "1.0.0"
 end

data/lib/http/2.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-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'
+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

data/sig/connection.rbs

@@ -0,0 +1,93 @@
+module HTTP2
+  class Connection
+    include FlowBuffer
+    include Emitter
+
+    REQUEST_MANDATORY_HEADERS: Array[String]
+    RESPONSE_MANDATORY_HEADERS: Array[String]
+
+    attr_reader state: Symbol
+
+    attr_reader local_window: Integer
+    attr_reader remote_window: Integer
+
+    alias window local_window
+
+    attr_reader remote_settings: settings_hash
+    attr_reader local_settings: settings_hash
+    attr_reader pending_settings: settings_ary
+
+    attr_accessor active_stream_count: Integer
+
+    @stream_id: Integer
+    @active_stream_count: Integer
+    @last_activated_stream: Integer
+    @last_stream_id: Integer
+
+    @streams: Hash[Integer, Stream]
+    @streams_recently_closed: Hash[Integer, Stream]
+
+    @framer: Framer
+
+    @local_window_limit: Integer
+    @remote_window_limit: Integer
+
+    @compressor: Header::Compressor
+    @decompressor: Header::Decompressor
+    @error: Symbol?
+
+    @recv_buffer: String
+    @continuation: Array[frame]
+
+    @closed_since: Float?
+    @received_frame: bool
+
+    def closed?: () -> bool
+
+    def new_stream: (**untyped) -> Stream
+
+    def ping: (String) -> void
+            | (String) { () -> void } -> void
+
+    def goaway: (?Symbol, ?String) -> void
+
+    def window_update: (Integer increment) -> void
+
+    def settings: (settings_enum) -> void
+
+    def receive: (string data) -> void
+    alias << receive
+
+    def initialize: (?settings_hash) -> void
+
+    private
+
+    def send: (frame) -> void
+
+    def encode: (frame) -> Array[String]
+
+    def connection_frame?: (frame) -> bool
+
+    def connection_management: (frame) -> void
+
+    def ping_management: (frame) -> void
+
+    def validate_settings: (:client | :server, settings_enum) -> void
+
+    def connection_settings: (frame) -> void
+
+    def decode_headers: (frame) -> void
+
+    def encode_headers: (frame) -> Array[frame]
+
+    def activate_stream: (id: Integer, **untyped) -> Stream
+
+    def verify_stream_order: (Integer id) -> void
+
+    def verify_pseudo_headers: (frame) -> void
+
+    def _verify_pseudo_headers: (frame, Array[String]) -> void
+
+    def connection_error: (?Symbol error, ?msg: String?, ?e: StandardError?) -> void
+  end
+end

data/sig/emitter.rbs

@@ -0,0 +1,13 @@
+module HTTP2
+  module Emitter
+    def on: (Symbol event) { (*untyped) -> void } -> void
+
+    def once: (Symbol event) { (*untyped) -> void } -> void
+
+    def emit: (Symbol event, *untyped args) ?{ (*untyped) -> void } -> void
+
+    private
+
+    def listeners: (Symbol event)  -> Array[Proc]
+  end
+end

data/sig/error.rbs

@@ -0,0 +1,35 @@
+module HTTP2
+  module Error
+    def self?.types: () -> Hash[Symbol, singleton(Error)]
+
+    class Error < StandardError
+    end
+
+    class HandshakeError < Error
+    end
+
+    class ProtocolError < Error
+    end
+
+    class CompressionError < ProtocolError
+    end
+
+    class FlowControlError < ProtocolError
+    end
+
+    class InternalError < ProtocolError
+    end
+
+    class StreamClosed < Error
+    end
+
+    class ConnectionClosed < Error
+    end
+
+    class StreamLimitExceeded < Error
+    end
+
+    class FrameSizeError < Error
+    end
+  end
+end

data/sig/extensions.rbs

@@ -0,0 +1,5 @@
+module HTTP2
+  module PackingExtensions
+    def pack: (Array[Integer] array_to_pack, String template, buffer: String, ?offset: Integer) -> String
+  end
+end

data/sig/flow_buffer.rbs

@@ -0,0 +1,21 @@
+module HTTP2
+  module FlowBuffer
+    MAX_WINDOW_SIZE: Integer
+
+    def buffered_amount: () -> Integer
+
+    def flush: () -> void
+
+    private
+
+    def send_buffer: () -> FrameBuffer
+
+    def update_local_window: (frame) -> void
+
+    def calculate_window_update: (Integer) -> void
+
+    def send_data: (?frame? frame, ?bool encode) -> void
+
+    def process_window_update: (frame: frame, ?encode: bool) -> void
+  end
+end

data/sig/frame_buffer.rbs

@@ -0,0 +1,13 @@
+module HTTP2
+  class FrameBuffer
+    attr_reader bytesize: Integer
+
+    @buffer: Array[data_frame]
+
+    def <<: (data_frame) -> void
+
+    def empty?: () -> bool
+
+    def retrieve: (Integer) -> data_frame?
+  end
+end

data/sig/framer.rbs

@@ -0,0 +1,54 @@
+module HTTP2
+  class Framer
+    include PackingExtensions
+
+    DEFAULT_MAX_FRAME_SIZE: Integer
+
+    MAX_STREAM_ID: Integer
+
+    MAX_WINDOWINC: Integer
+
+    FRAME_TYPES: Hash[Symbol, Integer]
+
+    FRAME_TYPES_WITH_PADDING: Array[Symbol]
+
+    FRAME_FLAGS: Hash[Symbol, Hash[Symbol, Integer]]
+
+    DEFINED_SETTINGS: Hash[Symbol, Integer]
+
+    DEFINED_ERRORS: Hash[Symbol, Integer]
+
+    RBIT: Integer
+    RBYTE: Integer
+    EBIT: Integer
+    UINT32: String
+    UINT16: String
+    UINT8: String
+    HEADERPACK: String
+    FRAME_LENGTH_HISHIFT: Integer
+    FRAME_LENGTH_LOMASK: Integer
+
+    @local_max_frame_size: Integer
+    @remote_max_frame_size: Integer
+
+    attr_accessor local_max_frame_size: Integer
+
+    attr_accessor remote_max_frame_size: Integer
+
+    def common_header: (frame, buffer: String) -> String
+
+    def read_common_frame: (String) -> frame
+
+    def generate: (frame) -> String
+
+    def parse: (String) -> frame?
+
+    private
+
+    def initialize: (?Integer local_max_frame_size, ?Integer remote_max_frame_size) -> untyped
+
+    def pack_error: (Integer | Symbol error, buffer: String) -> String
+
+    def unpack_error: (Integer) -> (Symbol | Integer)
+  end
+end

data/sig/header/compressor.rbs

@@ -0,0 +1,27 @@
+module HTTP2
+  module Header
+    class Compressor
+      include PackingExtensions
+
+      @cc: EncodingContext
+
+      def table_size=: (Integer) -> void
+
+      def integer: (Integer, Integer, buffer: String, ?offset: Integer) -> String
+
+      def string: (String) -> String
+
+      def header: (header_command, ?String) -> String
+
+      def encode: (Enumerable[header_pair]) -> String
+
+      private
+
+      def initialize: (?context_hash options) -> void
+
+      def huffman_string: (String str) -> String
+
+      def plain_string: (String str) -> String
+    end
+  end
+end