plum 0.0.1

data/lib/plum/hpack/context.rb

@@ -0,0 +1,55 @@
+module Plum
+  module HPACK
+    module Context
+      attr_reader :dynamic_table, :limit, :size
+
+      def limit=(value)
+        @limit = value
+        evict
+      end
+
+      private
+      def initialize(dynamic_table_limit)
+        @limit = dynamic_table_limit
+        @dynamic_table = []
+        @size = 0
+      end
+
+      def store(name, value)
+        @dynamic_table.unshift([name, value])
+        @size += name.bytesize + value.to_s.bytesize + 32
+        evict
+      end
+
+      def fetch(index)
+        if index == 0
+          raise HPACKError.new("index can't be 0")
+        elsif index <= STATIC_TABLE.size
+          STATIC_TABLE[index - 1]
+        elsif index <= STATIC_TABLE.size + @dynamic_table.size
+          @dynamic_table[index - STATIC_TABLE.size - 1]
+        else
+          raise HPACKError.new("invalid index: #{index}")
+        end
+      end
+
+      def search(name, value)
+        pr = proc {|n, v|
+          n == name && (!value || v == value)
+        }
+
+        si = STATIC_TABLE.index &pr
+        return si + 1 if si
+        di = @dynamic_table.index &pr
+        return di + STATIC_TABLE.size + 1 if di
+      end
+
+      def evict
+        while @limit && @size > @limit
+          name, value = @dynamic_table.pop
+          @size -= name.bytesize + value.to_s.bytesize + 32
+        end
+      end
+    end
+  end
+end

data/lib/plum/hpack/decoder.rb

@@ -0,0 +1,145 @@
+using Plum::BinaryString
+
+module Plum
+  module HPACK
+    class Decoder
+      include HPACK::Context
+
+      def initialize(dynamic_table_limit)
+        super
+      end
+
+      def decode(str)
+        str = str.dup
+        headers = []
+        headers << parse!(str) while str.size > 0
+        headers.compact
+      end
+
+      private
+      def parse!(str)
+        first_byte = str.uint8
+        if first_byte >= 128 # 0b1XXXXXXX
+          parse_indexed!(str)
+        elsif first_byte >= 64 # 0b01XXXXXX
+          parse_indexing!(str)
+        elsif first_byte >= 32 # 0b001XXXXX
+          self.limit = read_integer!(str, 5)
+          nil
+        else # 0b0000XXXX (without indexing) or 0b0001XXXX (never indexing)
+          parse_no_indexing!(str)
+        end
+      end
+
+      def read_integer!(str, prefix_length)
+        first_byte = str.byteshift(1).uint8
+        raise HPACKError.new("integer: end of buffer") unless first_byte
+
+        mask = (1 << prefix_length) - 1
+        ret = first_byte & mask
+        return ret if ret < mask
+
+        octets = 0
+        while next_value = str.byteshift(1).uint8
+          ret += (next_value & 0b01111111) << (7 * octets)
+          octets += 1
+
+          if next_value < 128
+            return ret
+          elsif octets == 4 # RFC 7541 5.1 tells us that we MUST have limitation. at least > 2 ** 28
+            raise HPACKError.new("integer: too large integer")
+          end
+        end
+
+        raise HPACKError.new("integer: end of buffer")
+      end
+
+      def read_string!(str)
+        first_byte = str.uint8
+        raise HPACKError.new("string: end of buffer") unless first_byte
+
+        huffman = (first_byte >> 7) == 1
+        length = read_integer!(str, 7)
+        bin = str.byteshift(length)
+
+        raise HTTPError.new("string: end of buffer") if bin.bytesize < length
+        bin = Huffman.decode(bin) if huffman
+        bin
+      end
+
+      def parse_indexed!(str)
+        # indexed
+        # +---+---+---+---+---+---+---+---+
+        # | 1 |        Index (7+)         |
+        # +---+---------------------------+
+        index = read_integer!(str, 7)
+        fetch(index)
+      end
+
+      def parse_indexing!(str)
+        # +---+---+---+---+---+---+---+---+
+        # | 0 | 1 |      Index (6+)       |
+        # +---+---+-----------------------+
+        # | H |     Value Length (7+)     |
+        # +---+---------------------------+
+        # | Value String (Length octets)  |
+        # +-------------------------------+
+        # or
+        # +---+---+---+---+---+---+---+---+
+        # | 0 | 1 |           0           |
+        # +---+---+-----------------------+
+        # | H |     Name Length (7+)      |
+        # +---+---------------------------+
+        # |  Name String (Length octets)  |
+        # +---+---------------------------+
+        # | H |     Value Length (7+)     |
+        # +---+---------------------------+
+        # | Value String (Length octets)  |
+        # +-------------------------------+
+        index = read_integer!(str, 6)
+        if index == 0
+          name = read_string!(str)
+        else
+          name, = fetch(index)
+        end
+
+        val = read_string!(str)
+        store(name, val)
+
+        [name, val]
+      end
+
+      def parse_no_indexing!(str)
+        # +---+---+---+---+---+---+---+---+
+        # | 0 | 0 | 0 |0,1|  Index (4+)   |
+        # +---+---+-----------------------+
+        # | H |     Value Length (7+)     |
+        # +---+---------------------------+
+        # | Value String (Length octets)  |
+        # +-------------------------------+
+        # or
+        # +---+---+---+---+---+---+---+---+
+        # | 0 | 0 | 0 |0,1|       0       |
+        # +---+---+-----------------------+
+        # | H |     Name Length (7+)      |
+        # +---+---------------------------+
+        # |  Name String (Length octets)  |
+        # +---+---------------------------+
+        # | H |     Value Length (7+)     |
+        # +---+---------------------------+
+        # | Value String (Length octets)  |
+        # +-------------------------------+
+        index = read_integer!(str, 4)
+        if index == 0
+          name = read_string!(str)
+        else
+          name, = fetch(index)
+        end
+
+        val = read_string!(str)
+
+        [name, val]
+      end
+    end
+  end
+end

data/lib/plum/hpack/encoder.rb

@@ -0,0 +1,105 @@
+using Plum::BinaryString
+
+module Plum
+  module HPACK
+    class Encoder
+      include HPACK::Context
+
+      def initialize(dynamic_table_limit)
+        super
+      end
+
+      def encode(headers)
+        out = ""
+        headers.each do |name, value|
+          name = name.to_s; value = value.to_s
+          if index = search(name, value)
+            out << encode_indexed(index)
+          elsif index = search(name, nil)
+            out << encode_half_indexed(index, value, true) # incremental indexing
+          else
+            out << encode_literal(name, value, true) # incremental indexing
+          end
+        end
+        out.force_encoding(Encoding::BINARY)
+      end
+
+      private
+      # +---+---+---+---+---+---+---+---+
+      # | 0 | 1 |           0           |
+      # +---+---+-----------------------+
+      # | H |     Name Length (7+)      |
+      # +---+---------------------------+
+      # |  Name String (Length octets)  |
+      # +---+---------------------------+
+      # | H |     Value Length (7+)     |
+      # +---+---------------------------+
+      # | Value String (Length octets)  |
+      # +-------------------------------+
+      def encode_literal(name, value, indexing = true)
+        if indexing
+          store(name, value)
+          fb = "\x40"
+        else
+          fb = "\x00"
+        end
+        fb << encode_string(name) << encode_string(value)
+      end
+
+      # +---+---+---+---+---+---+---+---+
+      # | 0 | 1 |      Index (6+)       |
+      # +---+---+-----------------------+
+      # | H |     Value Length (7+)     |
+      # +---+---------------------------+
+      # | Value String (Length octets)  |
+      # +-------------------------------+
+      def encode_half_indexed(index, value, indexing = true)
+        if indexing
+          store(fetch(index)[0], value)
+          fb = encode_integer(index, 6)
+          fb.setbyte(0, fb.uint8 | 0b01000000)
+        else
+          fb = encode_integer(index, 4)
+        end
+        fb << encode_string(value)
+      end
+
+      # +---+---+---+---+---+---+---+---+
+      # | 1 |        Index (7+)         |
+      # +---+---------------------------+
+      def encode_indexed(index)
+        s = encode_integer(index, 7)
+        s.setbyte(0, s.uint8 | 0b10000000)
+        s
+      end
+
+      def encode_integer(value, prefix_length)
+        mask = (1 << prefix_length) - 1
+        out = ""
+
+        if value < mask
+          out.push_uint8(value)
+        else
+          value -= mask
+          out.push_uint8(mask)
+          while value >= mask
+            out.push_uint8((value % 0b10000000) + 0b10000000)
+            value >>= 7
+          end
+          out.push_uint8(value)
+        end
+      end
+
+      def encode_string(str)
+        huffman_str = Huffman.encode(str).force_encoding(__ENCODING__)
+        if huffman_str.bytesize < str.bytesize
+          lenstr = encode_integer(huffman_str.bytesize, 7)
+          lenstr.setbyte(0, lenstr.uint8(0) | 0b10000000)
+          lenstr << huffman_str
+        else
+          encode_integer(str.bytesize, 7) << str
+        end
+      end
+    end
+  end
+end

data/lib/plum/hpack/huffman.rb

@@ -0,0 +1,42 @@
+using Plum::BinaryString
+
+module Plum
+  module HPACK
+    module Huffman
+      extend self
+
+      # Static-Huffman-encodes the specified String.
+      def encode(bytestr)
+        out = ""
+        bytestr.each_byte do |b|
+          out << HUFFMAN_TABLE[b]
+        end
+        out << "1" * ((8 - out.bytesize) % 8)
+        [out].pack("B*")
+      end
+
+      # Static-Huffman-decodes the specified String.
+      def decode(encoded)
+        bits = encoded.unpack("B*")[0]
+        out = []
+        buf = ""
+        bits.each_char do |cb|
+          buf << cb
+          if c = HUFFMAN_TABLE_INVERSED[buf]
+            raise HPACKError.new("huffman: EOS detected") if c == 256
+            out << c
+            buf = ""
+          end
+        end
+
+        if buf.bytesize > 7
+          raise HPACKError.new("huffman: padding is too large (> 7 bits)")
+        elsif buf != "1" * buf.bytesize
+          raise HPACKError.new("huffman: unknown suffix: #{buf}")
+        else
+          out.pack("C*")
+        end
+      end
+    end
+  end
+end

data/lib/plum/http_connection.rb

@@ -0,0 +1,33 @@
+module Plum
+  class HTTPConnection < Connection
+    def initialize(io, local_settings = {})
+      super
+    end
+
+    private
+    def negotiate!
+      if @buffer.bytesize >= 4
+        if CLIENT_CONNECTION_PREFACE.start_with?(@buffer)
+          negotiate_with_knowledge
+        else
+          negotiate_with_upgrade
+        end
+      end
+      # next
+    end
+
+    def negotiate_with_knowledge
+      if @buffer.bytesize >= 24
+        if @buffer.byteshift(24) == CLIENT_CONNECTION_PREFACE
+          @state = :waiting_settings
+          settings(@local_settings)
+        end
+      end
+      # next
+    end
+
+    def negotiate_with_upgrade
+      raise NotImplementedError, "Parsing HTTP/1.1 is hard..."
+    end
+  end
+end

data/lib/plum/https_connection.rb

@@ -0,0 +1,24 @@
+using Plum::BinaryString
+
+module Plum
+  class HTTPSConnection < Connection
+    def initialize(io, local_settings = {})
+      super
+    end
+
+    private
+    def negotiate!
+      return if @buffer.empty?
+
+      if CLIENT_CONNECTION_PREFACE.start_with?(@buffer.byteslice(0, 24))
+        if @buffer.bytesize >= 24
+          @buffer.byteshift(24)
+          @state = :waiting_settings
+          settings(@local_settings)
+        end
+      else
+        raise ConnectionError.new(:protocol_error) # (MAY) send GOAWAY. sending.
+      end
+    end
+  end
+end

data/lib/plum/stream.rb

@@ -0,0 +1,217 @@
+using Plum::BinaryString
+
+module Plum
+  class Stream
+    include EventEmitter
+    include FlowControl
+    include StreamUtils
+
+    attr_reader :id, :state, :connection
+    attr_reader :weight, :exclusive
+    attr_accessor :parent
+
+    def initialize(con, id, state: :idle, weight: 16, parent: nil, exclusive: false)
+      @connection = con
+      @id = id
+      @state = state
+      @continuation = []
+
+      initialize_flow_control(send: @connection.remote_settings[:initial_window_size],
+                              recv: @connection.local_settings[:initial_window_size])
+      update_dependency(weight: weight, parent: parent, exclusive: exclusive)
+    end
+
+    # Returns the child (depending on this stream) streams.
+    #
+    # @return [Array<Stream>] The child streams.
+    def children
+      @connection.streams.values.select {|c| c.parent == self }.freeze
+    end
+
+    # Processes received frames for this stream. Internal use.
+    # @private
+    def receive_frame(frame)
+      validate_received_frame(frame)
+      consume_recv_window(frame)
+
+      case frame.type
+      when :data
+        receive_data(frame)
+      when :headers
+        receive_headers(frame)
+      when :priority
+        receive_priority(frame)
+      when :rst_stream
+        receive_rst_stream(frame)
+      when :window_update
+        receive_window_update(frame)
+      when :continuation
+        receive_continuation(frame)
+      when :ping, :goaway, :settings, :push_promise
+        raise ConnectionError.new(:protocol_error) # stream_id MUST be 0x00
+      else
+        # MUST ignore unknown frame
+      end
+    rescue StreamError => e
+      callback(:stream_error, e)
+      close(e.http2_error_type)
+    end
+
+    # Closes this stream. Sends RST_STREAM frame to the peer.
+    #
+    # @param error_type [Symbol] The error type to be contained in the RST_STREAM frame.
+    def close(error_type = :no_error)
+      @state = :closed
+      send_immediately Frame.rst_stream(id, error_type)
+    end
+
+    private
+    def send_immediately(frame)
+      callback(:send_frame, frame)
+      @connection.send(frame)
+    end
+
+    def update_dependency(weight: nil, parent: nil, exclusive: nil)
+      raise StreamError.new(:protocol_error, "A stream cannot depend on itself.") if parent == self
+      @weight = weight unless weight.nil?
+      @parent = parent unless parent.nil?
+      @exclusive = exclusive unless exclusive.nil?
+
+      if exclusive == true
+        parent.children.each do |child|
+          next if child == self
+          child.parent = self
+        end
+      end
+    end
+
+    def validate_received_frame(frame)
+      if frame.length > @connection.local_settings[:max_frame_size]
+        if [:headers, :push_promise, :continuation].include?(frame.type)
+          raise ConnectionError.new(:frame_size_error)
+        else
+          raise StreamError.new(:frame_size_error)
+        end
+      end
+    end
+
+    def receive_end_stream
+      callback(:end_stream)
+      @state = :half_closed_remote
+    end
+
+    def receive_data(frame)
+      if @state != :open && @state != :half_closed_local
+        raise StreamError.new(:stream_closed)
+      end
+
+      if frame.flags.include?(:padded)
+        padding_length = frame.payload.uint8(0)
+        if padding_length >= frame.length
+          raise ConnectionError.new(:protocol_error, "padding is too long")
+        end
+        body = frame.payload.byteslice(1, frame.length - padding_length - 1)
+      else
+        body = frame.payload
+      end
+      callback(:data, body)
+
+      receive_end_stream if frame.flags.include?(:end_stream)
+    end
+
+    def receive_complete_headers(frames)
+      frames = frames.dup
+      first = frames.shift
+
+      payload = first.payload
+      first_length = first.length
+      padding_length = 0
+
+      if first.flags.include?(:padded)
+        padding_length = payload.uint8
+        first_length -= 1 + padding_length
+        payload = payload.byteslice(1, first_length)
+      else
+        payload = payload.dup
+      end
+
+      if first.flags.include?(:priority)
+        receive_priority_payload(payload.byteshift(5))
+        first_length -= 5
+      end
+
+      if padding_length > first_length
+        raise ConnectionError.new(:protocol_error, "padding is too long")
+      end
+
+      frames.each do |frame|
+        payload << frame.payload
+      end
+
+      begin
+        decoded_headers = @connection.hpack_decoder.decode(payload)
+      rescue => e
+        raise ConnectionError.new(:compression_error, e)
+      end
+
+      callback(:headers, decoded_headers)
+
+      receive_end_stream if first.flags.include?(:end_stream)
+    end
+
+    def receive_headers(frame)
+      if @state == :reserved_local
+        raise ConnectionError.new(:protocol_error)
+      elsif @state == :half_closed_remote
+        raise StreamError.new(:stream_closed)
+      elsif @state == :closed
+        raise ConnectionError.new(:stream_closed)
+      end
+
+      @state = :open
+      callback(:open)
+
+      if frame.flags.include?(:end_headers)
+        receive_complete_headers([frame])
+      else
+        @continuation << frame
+      end
+    end
+
+    def receive_continuation(frame)
+      # state error mustn't happen: server_connection validates
+      @continuation << frame
+
+      if frame.flags.include?(:end_headers)
+        receive_complete_headers(@continuation)
+        @continuation.clear
+      end
+    end
+
+    def receive_priority(frame)
+      if frame.length != 5
+        raise StreamError.new(:frame_size_error)
+      end
+      receive_priority_payload(frame.payload)
+    end
+
+    def receive_priority_payload(payload)
+      esd = payload.uint32
+      e = esd >> 31
+      dependency_id = e & ~(1 << 31)
+      weight = payload.uint8(4)
+
+      update_dependency(weight: weight, parent: @connection.streams[dependency_id], exclusive: e == 1)
+    end
+
+    def receive_rst_stream(frame)
+      if frame.length != 4
+        raise ConnectionError.new(:frame_size_error)
+      elsif @state == :idle
+        raise ConnectionError.new(:protocol_error)
+      end
+
+      @state = :closed # MUST NOT send RST_STREAM
+    end
+  end
+end