biryani 0.0.1

data/lib/biryani/frame/headers.rb

@@ -0,0 +1,110 @@
+module Biryani
+  module Frame
+    class Headers
+      attr_reader :f_type, :stream_id, :stream_dependency, :weight, :fragment, :padding
+
+      # @param end_headers [Boolean]
+      # @param end_stream [Boolean]
+      # @param stream_id [Integer]
+      # @param stream_dependency [Integer, nil]
+      # @param weight [Integer, nil]
+      # @param fragment [String]
+      # @param padding [String, nil]
+      # rubocop: disable Metrics/ParameterLists
+      def initialize(end_headers, end_stream, stream_id, stream_dependency, weight, fragment, padding)
+        @f_type = FrameType::HEADERS
+        @end_headers = end_headers
+        @end_stream = end_stream
+        @stream_id = stream_id
+        @stream_dependency = stream_dependency
+        @weight = weight
+        @fragment = fragment
+        @padding = padding
+      end
+      # rubocop: enable Metrics/ParameterLists
+
+      # @return [Boolean]
+      def priority?
+        !@stream_dependency.nil? && !@weight.nil?
+      end
+
+      # @return [Boolean]
+      def padded?
+        !@padding.nil?
+      end
+
+      # @return [Boolean]
+      def end_headers?
+        @end_headers
+      end
+
+      # @return [Boolean]
+      def end_stream?
+        @end_stream
+      end
+
+      # @return [Integer]
+      def length
+        @fragment.bytesize + (padded? ? 1 + @padding.bytesize : 0) + (priority? ? 5 : 0)
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = Frame.to_flags(priority: priority?, padded: padded?, end_headers: end_headers?, end_stream: end_stream?)
+        pad_length = padded? ? @padding.bytesize.chr : ''
+        stream_dependency_weight = priority? ? [@stream_dependency, @weight].pack('NC') : ''
+        padding = @padding || ''
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + pad_length + stream_dependency_weight + @fragment + padding
+      end
+
+      # @param s [String]
+      #
+      # @return [Headers]
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+      def self.read(s)
+        payload_length, _, flags, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+
+        priority = Frame.read_priority(flags)
+        padded = Frame.read_padded(flags)
+        end_headers = Frame.read_end_headers(flags)
+        end_stream = Frame.read_end_stream(flags)
+
+        if priority && padded
+          pad_length, stream_dependency, weight = s[9..14].unpack('CNC')
+          fragment_length = payload_length - pad_length - 6
+          # exclusive = (stream_dependency / 2**31).positive?
+          stream_dependency %= 2**31
+          fragment = s[15...15 + fragment_length]
+          padding = s[15 + fragment_length..]
+          return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame') if padding.bytesize != pad_length
+        elsif priority
+          stream_dependency, weight = s[9..13].unpack('NC')
+          # exclusive = (stream_dependency / 2**31).positive?
+          stream_dependency %= 2**31
+          fragment = s[14..]
+          return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame') if fragment.bytesize + 5 != payload_length
+        elsif padded
+          pad_length = s[9].unpack1('C')
+          fragment_length = payload_length - pad_length - 1
+          fragment = s[10...10 + fragment_length]
+          padding = s[10 + fragment_length..]
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if pad_length >= payload_length
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if padding.bytesize != pad_length
+        else
+          fragment = s[9..]
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if fragment.bytesize != payload_length
+        end
+
+        Headers.new(end_headers, end_stream, stream_id, stream_dependency, weight, fragment, padding)
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/biryani/frame/ping.rb

@@ -0,0 +1,49 @@
+module Biryani
+  module Frame
+    class Ping
+      attr_reader :f_type, :stream_id, :opaque
+
+      # @param ack [Boolean]
+      # @param stream_id [Integer]
+      # @param opaque [String]
+      def initialize(ack, stream_id, opaque)
+        @f_type = FrameType::PING
+        @ack = ack
+        @stream_id = stream_id
+        @opaque = opaque
+      end
+
+      # @return [Boolean]
+      def ack?
+        @ack
+      end
+
+      # @return [Integer]
+      def length
+        8
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = Frame.to_flags(ack: ack?)
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + opaque
+      end
+
+      # @param s [String]
+      #
+      # @return [Ping]
+      def self.read(s)
+        payload_length, _, flags, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'PING payload length MUST be 8') if s[9..].bytesize != 8
+
+        ack = Frame.read_ack(flags)
+        opaque = s[9..]
+
+        Ping.new(ack, stream_id, opaque)
+      end
+    end
+  end
+end

data/lib/biryani/frame/priority.rb

@@ -0,0 +1,44 @@
+module Biryani
+  module Frame
+    class Priority
+      attr_reader :f_type, :stream_id, :stream_dependency, :weight
+
+      # @param stream_id [Integer]
+      # @param stream_dependency [Integer]
+      # @param weight [Integer]
+      def initialize(stream_id, stream_dependency, weight)
+        @f_type = FrameType::PRIORITY
+        @stream_id = stream_id
+        @stream_dependency = stream_dependency
+        @weight = weight
+      end
+
+      # @return [Integer]
+      def length
+        5
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = 0x00
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + [@stream_dependency, @weight].pack('NC')
+      end
+
+      # @param s [String]
+      #
+      # @return [Priority]
+      def self.read(s)
+        payload_length, _, _, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'PRIORITY payload length MUST be 5') if payload_length != 5
+
+        stream_dependency, weight = s[9..13].unpack('NC')
+        stream_dependency %= 2**31
+
+        Priority.new(stream_id, stream_dependency, weight)
+      end
+    end
+  end
+end

data/lib/biryani/frame/push_promise.rb

@@ -0,0 +1,75 @@
+module Biryani
+  module Frame
+    class PushPromise
+      attr_reader :f_type, :stream_id, :promised_stream_id, :fragment, :padding
+
+      # @param end_headers [Boolean]
+      # @param stream_id [Integer]
+      # @param promised_stream_id [Integer]
+      # @param fragment [String]
+      # @param padding [String, nil]
+      def initialize(end_headers, stream_id, promised_stream_id, fragment, padding)
+        @f_type = FrameType::PUSH_PROMISE
+        @end_headers = end_headers
+        @stream_id = stream_id
+        @promised_stream_id = promised_stream_id
+        @fragment = fragment
+        @padding = padding
+      end
+
+      # @return [Boolean]
+      def padded?
+        !@padding.nil?
+      end
+
+      # @return [Boolean]
+      def end_headers?
+        @end_headers
+      end
+
+      # @return [Integer]
+      def length
+        @fragment.bytesize + 4 + (padded? ? 1 + @padding.bytesize : 0)
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = Frame.to_flags(padded: padded?, end_headers: end_headers?)
+        pad_length = padded? ? @padding.bytesize.chr : ''
+        padding = @padding || ''
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + pad_length + [@promised_stream_id].pack('N') + @fragment + padding
+      end
+
+      # @param s [String]
+      #
+      # @return [PushPromise]
+      # rubocop: disable Metrics/AbcSize
+      def self.read(s)
+        payload_length, _, flags, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+
+        padded = Frame.read_padded(flags)
+        end_headers = Frame.read_end_headers(flags)
+
+        if padded
+          pad_length = s[9].unpack1('C')
+          promised_stream_id = s[10..13].unpack1('N')
+          fragment_length = payload_length - pad_length - 5
+          fragment = s[14...14 + fragment_length]
+          padding = s[14 + fragment_length..]
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if pad_length >= payload_length
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if padding.bytesize != pad_length
+        else
+          promised_stream_id = s[9..12].unpack1('N')
+          fragment = s[13..]
+          return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if fragment.bytesize + 4 != payload_length
+        end
+
+        PushPromise.new(end_headers, stream_id, promised_stream_id, fragment, padding)
+      end
+      # rubocop: enable Metrics/AbcSize
+    end
+  end
+end

data/lib/biryani/frame/rst_stream.rb

@@ -0,0 +1,40 @@
+module Biryani
+  module Frame
+    class RstStream
+      attr_reader :f_type, :stream_id, :error_code
+
+      # @param stream_id [Integer]
+      # @param error_code [Integer]
+      def initialize(stream_id, error_code)
+        @f_type = FrameType::RST_STREAM
+        @stream_id = stream_id
+        @error_code = error_code
+      end
+
+      # @return [Integer]
+      def length
+        4
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = 0x00
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + [@error_code].pack('N')
+      end
+
+      # @param s [String]
+      #
+      # @return [RstStream]
+      def self.read(s)
+        payload_length, _, _, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'RST_STREAM payload length MUST be 4') if s[9..].bytesize != 4
+
+        error_code = s[9..].unpack1('N')
+        RstStream.new(stream_id, error_code)
+      end
+    end
+  end
+end

data/lib/biryani/frame/settings.rb

@@ -0,0 +1,66 @@
+module Biryani
+  module Frame
+    class Settings
+      attr_reader :f_type, :stream_id, :setting
+
+      # @param ack [Boolean]
+      # @param stream_id [Integer]
+      # @param setting [Hash<Integer, Integer>] uint16 uint32
+      def initialize(ack, stream_id, setting)
+        @f_type = FrameType::SETTINGS
+        @ack = ack
+        @stream_id = stream_id
+        @setting = setting
+      end
+
+      # @return [Boolean]
+      def ack?
+        @ack
+      end
+
+      # @return [Integer]
+      def length
+        @setting.length * 6
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = Frame.to_flags(ack: ack?)
+        setting = @setting.map { |x| x.pack('nN') }.join
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + setting
+      end
+
+      # @param s [String]
+      #
+      # @return [Settings]
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+      def self.read(s)
+        payload_length, _, flags, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'SETTINGS payload length MUST be a multiple of 6') if payload_length % 6 != 0
+
+        ack = Frame.read_ack(flags)
+        setting = s[9..].unpack('nN' * (payload_length / 6)).each_slice(2).to_h
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'SETTINGS MUST NOT have setting with ack') \
+          if ack && setting.any?
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid SETTINGS_ENABLE_PUSH') \
+          if setting.key?(SettingsID::SETTINGS_ENABLE_PUSH) && ![0, 1].include?(setting[SettingsID::SETTINGS_ENABLE_PUSH])
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid SETTINGS_MAX_FRAME_SIZE') \
+          if setting.key?(SettingsID::SETTINGS_MAX_FRAME_SIZE) && setting[SettingsID::SETTINGS_MAX_FRAME_SIZE] < 16_384
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid SETTINGS_MAX_FRAME_SIZE') \
+          if setting.key?(SettingsID::SETTINGS_MAX_FRAME_SIZE) && setting[SettingsID::SETTINGS_MAX_FRAME_SIZE] > 16_777_215
+        return ConnectionError.new(ErrorCode::FLOW_CONTROL_ERROR, 'invalid SETTINGS_INITIAL_WINDOW_SIZE') \
+          if setting.key?(SettingsID::SETTINGS_INITIAL_WINDOW_SIZE) && setting[SettingsID::SETTINGS_INITIAL_WINDOW_SIZE] > 2_147_483_647
+
+        Settings.new(ack, stream_id, setting)
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/biryani/frame/unknown.rb

@@ -0,0 +1,42 @@
+module Biryani
+  module Frame
+    class Unknown
+      attr_reader :f_type, :flags, :stream_id, :payload
+
+      # @param f_type [Integer]
+      # @param flags [Integer]
+      # @param stream_id [Integer]
+      # @param payload [String, nil]
+      def initialize(f_type, flags, stream_id, payload)
+        @f_type = f_type
+        @flags = flags
+        @stream_id = stream_id
+        @payload = payload
+      end
+
+      # @return [Integer]
+      def length
+        @payload.bytesize
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + @payload
+      end
+
+      # @param s [String]
+      #
+      # @return [Unknown]
+      def self.read(s)
+        payload_length, f_type, flags, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+
+        payload = s[9..]
+
+        Unknown.new(f_type, flags, stream_id, payload)
+      end
+    end
+  end
+end

data/lib/biryani/frame/window_update.rb

@@ -0,0 +1,43 @@
+module Biryani
+  module Frame
+    class WindowUpdate
+      attr_reader :f_type, :stream_id, :window_size_increment
+
+      # @param stream_id [Integer]
+      # @param window_size_increment [Integer]
+      def initialize(stream_id, window_size_increment)
+        @f_type = FrameType::WINDOW_UPDATE
+        @stream_id = stream_id
+        @window_size_increment = window_size_increment
+      end
+
+      # @return [Integer]
+      def length
+        4
+      end
+
+      # @return [String]
+      def to_binary_s
+        payload_length = length
+        flags = 0x00
+
+        Frame.to_binary_s_header(payload_length, @f_type, flags, @stream_id) + [@window_size_increment].pack('N')
+      end
+
+      # @param s [String]
+      #
+      # @return [WindowUpdate]
+      def self.read(s)
+        payload_length, _, _, stream_id = Frame.read_header(s)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if s[9..].bytesize != payload_length
+        return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'WINDOW_UPDATE payload length MUST be 4') if s[9..].bytesize != 4
+
+        window_size_increment = s[9..].unpack1('N')
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'WINDOW_UPDATE invalid window size increment 0') if window_size_increment.zero?
+        return ConnectionError.new(ErrorCode::FLOW_CONTROL_ERROR, 'WINDOW_UPDATE invalid window size increment greater than 2^31-1') if window_size_increment > 2**31 - 1
+
+        WindowUpdate.new(stream_id, window_size_increment)
+      end
+    end
+  end
+end

data/lib/biryani/frame.rb

@@ -0,0 +1,146 @@
+module Biryani
+  module FrameType
+    DATA          = 0x00
+    HEADERS       = 0x01
+    PRIORITY      = 0x02
+    RST_STREAM    = 0x03
+    SETTINGS      = 0x04
+    PUSH_PROMISE  = 0x05
+    PING          = 0x06
+    GOAWAY        = 0x07
+    WINDOW_UPDATE = 0x08
+    CONTINUATION  = 0x09
+  end
+
+  module ErrorCode
+    NO_ERROR            = 0x00
+    PROTOCOL_ERROR      = 0x01
+    INTERNAL_ERROR      = 0x02
+    FLOW_CONTROL_ERROR  = 0x03
+    SETTINGS_TIMEOUT    = 0x04
+    STREAM_CLOSED       = 0x05
+    FRAME_SIZE_ERROR    = 0x06
+    REFUSED_STREAM      = 0x07
+    CANCEL              = 0x08
+    COMPRESSION_ERROR   = 0x09
+    CONNECT_ERROR       = 0x0a
+    ENHANCE_YOUR_CALM   = 0x0b
+    INADEQUATE_SECURITY = 0x0c
+    HTTP_1_1_REQUIRED   = 0x0d
+  end
+
+  module Frame
+    # @param s [String]
+    #
+    # @return [Integer]
+    # @return [Integer]
+    # @return [Integer]
+    # @return [Integer]
+    def self.read_header(s)
+      b0, b1, b2, f_type, uint8 = s[0..4].bytes
+      payload_length = (b0 << 16) | (b1 << 8) | b2
+      stream_id = s[5..8].unpack1('N') % 2**31 # Stream Identifier (31)
+
+      [payload_length, f_type, uint8, stream_id]
+    end
+
+    # @param uint8 [Integer]
+    #
+    # @return [Boolean]
+    def self.read_priority(uint8)
+      (uint8 & 0b00100000).positive?
+    end
+
+    # @param uint8 [Integer]
+    #
+    # @return [Boolean]
+    def self.read_padded(uint8)
+      (uint8 & 0b00001000).positive?
+    end
+
+    # @param uint8 [Integer]
+    #
+    # @return [Boolean]
+    def self.read_end_headers(uint8)
+      (uint8 & 0b00000100).positive?
+    end
+
+    # @param uint8 [Integer]
+    #
+    # @return [Boolean]
+    def self.read_end_stream(uint8)
+      (uint8 & 0b00000001).positive?
+    end
+
+    # @param uint8 [Integer]
+    #
+    # @return [Boolean]
+    def self.read_ack(uint8)
+      (uint8 & 0b00000001).positive?
+    end
+
+    # @return [Integer]
+    def self.to_flags(priority: false, padded: false, end_headers: false, end_stream: false, ack: false)
+      (priority ? 32 : 0) + (padded ? 8 : 0) + (end_headers ? 4 : 0) + (end_stream || ack ? 1 : 0)
+    end
+
+    # @param payload_length [Integer]
+    # @param f_type [Integer]
+    # @param flags [Integer]
+    # @param stream_id
+    #
+    # @return [String]
+    def self.to_binary_s_header(payload_length, f_type, flags, stream_id)
+      [payload_length, f_type, flags, stream_id].pack('NCCN')[1..]
+    end
+  end
+end
+
+require_relative 'frame/continuation'
+require_relative 'frame/data'
+require_relative 'frame/goaway'
+require_relative 'frame/headers'
+require_relative 'frame/ping'
+require_relative 'frame/priority'
+require_relative 'frame/push_promise'
+require_relative 'frame/rst_stream'
+require_relative 'frame/settings'
+require_relative 'frame/unknown'
+require_relative 'frame/window_update'
+
+module Biryani
+  module Frame
+    FRAME_MAP = {
+      FrameType::DATA => Data,
+      FrameType::HEADERS => Headers,
+      FrameType::PRIORITY => Priority,
+      FrameType::RST_STREAM => RstStream,
+      FrameType::SETTINGS => Settings,
+      FrameType::PUSH_PROMISE => PushPromise,
+      FrameType::PING => Ping,
+      FrameType::GOAWAY => Goaway,
+      FrameType::WINDOW_UPDATE => WindowUpdate,
+      FrameType::CONTINUATION => Continuation
+    }.freeze
+
+    private_constant :FRAME_MAP
+    Ractor.make_shareable(FRAME_MAP)
+
+    # @param io [IO]
+    #
+    # @return [Object, nil, ConnectionError] frame or error
+    def self.read(io)
+      s = io.read(9)
+      return nil if s.nil?
+      return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid header length') if s.bytesize != 9
+
+      payload_length, f_type, flags, stream_id = read_header(s)
+      payload = io.read(payload_length)
+      return Frame::Unknown.new(f_type, flags, stream_id, payload) unless FRAME_MAP.key?(f_type)
+
+      FRAME_MAP[f_type].read(s + payload)
+    rescue StandardError
+      ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame')
+    end
+  end
+end

data/lib/biryani/hpack/decoder.rb

@@ -0,0 +1,22 @@
+module Biryani
+  module HPACK
+    class Decoder
+      # @param dynamic_table_limit [Integer]
+      def initialize(dynamic_table_limit)
+        @dynamic_table = DynamicTable.new(dynamic_table_limit)
+      end
+
+      # @param s [String]
+      #
+      # @return [Array]
+      def decode(s)
+        Fields.decode(s.force_encoding(Encoding::ASCII_8BIT), @dynamic_table)
+      end
+
+      # @param new_limit [Integer]
+      def limit!(new_limit)
+        @dynamic_table.limit!(new_limit)
+      end
+    end
+  end
+end