plum 0.0.1

data/lib/plum.rb

@@ -0,0 +1,21 @@
+require "openssl"
+require "socket"
+require "plum/version"
+require "plum/errors"
+require "plum/binary_string"
+require "plum/event_emitter"
+require "plum/hpack/constants"
+require "plum/hpack/huffman"
+require "plum/hpack/context"
+require "plum/hpack/decoder"
+require "plum/hpack/encoder"
+require "plum/frame_utils"
+require "plum/frame_factory"
+require "plum/frame"
+require "plum/flow_control"
+require "plum/connection_utils"
+require "plum/connection"
+require "plum/https_connection"
+require "plum/http_connection"
+require "plum/stream_utils"
+require "plum/stream"

data/lib/plum/binary_string.rb

@@ -0,0 +1,74 @@
+module Plum
+  module BinaryString
+    refine String do
+      # Reads a 8-bit unsigned integer.
+      # @param pos [Integer] The start position to read.
+      def uint8(pos = 0)
+        byteslice(pos, 1).unpack("C")[0]
+      end
+
+      # Reads a 16-bit unsigned integer.
+      # @param pos [Integer] The start position to read.
+      def uint16(pos = 0)
+        byteslice(pos, 2).unpack("n")[0]
+      end
+
+      # Reads a 24-bit unsigned integer.
+      # @param pos [Integer] The start position to read.
+      def uint24(pos = 0)
+        (uint16(pos) << 8) | uint8(pos + 2)
+      end
+
+      # Reads a 32-bit unsigned integer.
+      # @param pos [Integer] The start position to read.
+      def uint32(pos = 0)
+        byteslice(pos, 4).unpack("N")[0]
+      end
+
+      # Appends a 8-bit unsigned integer to this string.
+      def push_uint8(val)
+        self << [val].pack("C")
+      end
+
+      # Appends a 16-bit unsigned integer to this string.
+      def push_uint16(val)
+        self << [val].pack("n")
+      end
+
+      # Appends a 24-bit unsigned integer to this string.
+      def push_uint24(val)
+        push_uint16(val >> 8)
+        push_uint8(val & ((1 << 8) - 1))
+      end
+
+      # Appends a 32-bit unsigned integer to this string.
+      def push_uint32(val)
+        self << [val].pack("N")
+      end
+
+      alias push <<
+
+      # Takes from beginning and cut specified *octets* from this String.
+      # @param count [Integer] The amount.
+      def byteshift(count)
+        force_encoding(Encoding::BINARY)
+        slice!(0, count)
+      end
+
+      def each_byteslice(n, &blk)
+        if block_given?
+          pos = 0
+          while pos < self.bytesize
+            yield byteslice(pos, n)
+            pos += n
+          end
+        else
+          Enumerator.new do |y|
+            each_byteslice(n) {|ss| y << ss }
+          end
+          # I want to write `enum_for(__method__, n)`!
+        end
+      end
+    end
+  end
+end

data/lib/plum/connection.rb

@@ -0,0 +1,201 @@
+using Plum::BinaryString
+
+module Plum
+  class Connection
+    include EventEmitter
+    include FlowControl
+    include ConnectionUtils
+
+    CLIENT_CONNECTION_PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+
+    DEFAULT_SETTINGS = {
+      header_table_size:      4096,     # octets
+      enable_push:            1,        # 1: enabled, 0: disabled
+      max_concurrent_streams: 1 << 30,  # (1 << 31) / 2
+      initial_window_size:    65535,    # octets; <= 2 ** 31 - 1
+      max_frame_size:         16384,    # octets; <= 2 ** 24 - 1
+      max_header_list_size:   (1 << 32) - 1 # Fixnum
+    }
+
+    attr_reader :hpack_encoder, :hpack_decoder
+    attr_reader :local_settings, :remote_settings
+    attr_reader :state, :streams, :io
+
+    def initialize(io, local_settings = {})
+      @io = io
+      @local_settings = Hash.new {|hash, key| DEFAULT_SETTINGS[key] }.merge!(local_settings)
+      @remote_settings = Hash.new {|hash, key| DEFAULT_SETTINGS[key] }
+      @buffer = "".force_encoding(Encoding::BINARY)
+      @streams = {}
+      @state = :negotiation
+      @hpack_decoder = HPACK::Decoder.new(@local_settings[:header_table_size])
+      @hpack_encoder = HPACK::Encoder.new(@remote_settings[:header_table_size])
+      initialize_flow_control(send: @remote_settings[:initial_window_size],
+                              recv: @local_settings[:initial_window_size])
+    end
+    private :initialize
+
+    # Starts communication with the peer. It blocks until the io is closed, or reaches EOF.
+    def run
+      while !@io.closed? && !@io.eof?
+        receive @io.readpartial(1024)
+      end
+    end
+
+    # Closes the io.
+    def close
+      # TODO: server MAY wait streams
+      @io.close
+    end
+
+    # Receives the specified data and process.
+    #
+    # @param new_data [String] The data received from the peer.
+    def receive(new_data)
+      return if new_data.empty?
+      @buffer << new_data
+
+      if @state == :negotiation
+        negotiate!
+      end
+
+      if @state != :negotiation
+        while frame = Frame.parse!(@buffer)
+          callback(:frame, frame)
+          receive_frame(frame)
+        end
+      end
+    rescue ConnectionError => e
+      callback(:connection_error, e)
+      goaway(e.http2_error_type)
+      close
+    end
+    alias << receive
+
+    # Reserves a new stream to server push.
+    #
+    # @param args [Hash] The argument to pass to Stram.new.
+    def reserve_stream(**args)
+      next_id = ((@streams.keys.last / 2).to_i + 1) * 2
+      stream = new_stream(next_id, state: :reserved_local, **args)
+      stream
+    end
+
+    private
+    def send_immediately(frame)
+      callback(:send_frame, frame)
+      @io.write(frame.assemble)
+    end
+
+    def new_stream(stream_id, **args)
+      if @streams.size > 0 && @streams.keys.last >= stream_id
+        raise Plum::ConnectionError.new(:protocol_error)
+      end
+
+      stream = Stream.new(self, stream_id, **args)
+      callback(:stream, stream)
+      @streams[stream_id] = stream
+      stream
+    end
+
+    def validate_received_frame(frame)
+      case @state
+      when :waiting_settings
+        raise ConnectionError.new(:protocol_error) if frame.type != :settings
+        @state = :negotiated
+        callback(:negotiated)
+      when :waiting_continuation
+        if frame.type != :continuation || frame.stream_id != @continuation_id
+          raise Plum::ConnectionError.new(:protocol_error)
+        end
+
+        if frame.flags.include?(:end_headers)
+          @state = :open
+          @continuation_id = nil
+        end
+      else
+        if [:headers].include?(frame.type)
+          if !frame.flags.include?(:end_headers)
+            @state = :waiting_continuation
+            @continuation_id = frame.stream_id
+          end
+        end
+      end
+    end
+
+    def receive_frame(frame)
+      validate_received_frame(frame)
+      consume_recv_window(frame)
+
+      if frame.stream_id == 0
+        receive_control_frame(frame)
+      else
+        if @streams.key?(frame.stream_id)
+          stream = @streams[frame.stream_id]
+        else
+          if frame.stream_id.even? # stream started by client must have odd ID
+            raise Plum::ConnectionError.new(:protocol_error)
+          end
+          stream = new_stream(frame.stream_id)
+        end
+        stream.receive_frame(frame)
+      end
+    end
+
+    def receive_control_frame(frame)
+      if frame.length > @local_settings[:max_frame_size]
+        raise ConnectionError.new(:frame_size_error)
+      end
+
+      case frame.type
+      when :settings
+        receive_settings(frame)
+      when :window_update
+        receive_window_update(frame)
+      when :ping
+        receive_ping(frame)
+      when :goaway
+        goaway
+        close
+      when :data, :headers, :priority, :rst_stream, :push_promise, :continuation
+        raise Plum::ConnectionError.new(:protocol_error)
+      else
+        # MUST ignore unknown frame type.
+      end
+    end
+
+    def receive_settings(frame)
+      if frame.flags.include?(:ack)
+        raise ConnectionError.new(:frame_size_error) if frame.length != 0
+        return
+      end
+
+      raise ConnectionError.new(:frame_size_error) if frame.length % 6 != 0
+
+      old_remote_settings = @remote_settings.dup
+      @remote_settings.merge!(frame.parse_settings)
+      apply_remote_settings(old_remote_settings)
+
+      callback(:remote_settings, @remote_settings, old_remote_settings)
+
+      send_immediately Frame.settings(:ack)
+    end
+
+    def apply_remote_settings(old_remote_settings)
+      @hpack_encoder.limit = @remote_settings[:header_table_size]
+      update_send_initial_window_size(@remote_settings[:initial_window_size] - old_remote_settings[:initial_window_size])
+    end
+
+    def receive_ping(frame)
+      raise Plum::ConnectionError.new(:frame_size_error) if frame.length != 8
+
+      if frame.flags.include?(:ack)
+        on(:ping_ack)
+      else
+        on(:ping)
+        opaque_data = frame.payload
+        send_immediately Frame.ping(:ack, opaque_data)
+      end
+    end
+  end
+end

data/lib/plum/connection_utils.rb

@@ -0,0 +1,38 @@
+using Plum::BinaryString
+
+module Plum
+  module ConnectionUtils
+    # Sends local settings to the peer.
+    #
+    # @param kwargs [Hash<Symbol, Integer>]
+    def settings(**kwargs)
+      send_immediately Frame.settings(**kwargs)
+      update_local_settings(kwargs)
+    end
+
+    # Sends a PING frame to the peer.
+    #
+    # @param data [String] Must be 8 octets.
+    # @raise [ArgumentError] If the data is not 8 octets.
+    def ping(data = "plum\x00\x00\x00\x00")
+      send_immediately Frame.ping(data)
+    end
+
+    # Sends GOAWAY frame to the peer and closes the connection.
+    #
+    # @param error_type [Symbol] The error type to be contained in the GOAWAY frame.
+    def goaway(error_type = :no_error)
+      last_id = @streams.keys.max || 0
+      send_immediately Frame.goaway(last_id, error_type)
+    end
+
+    private
+    def update_local_settings(new_settings)
+      old_settings = @local_settings.dup
+      @local_settings.merge!(new_settings)
+
+      @hpack_decoder.limit = @local_settings[:header_table_size]
+      update_recv_initial_window_size(@local_settings[:initial_window_size] - old_settings[:initial_window_size])
+    end
+  end
+end

data/lib/plum/errors.rb

@@ -0,0 +1,35 @@
+module Plum
+  class Error < StandardError; end
+  class HPACKError < Error; end
+  class HTTPError < Error
+    ERROR_CODES = {
+      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
+    }
+
+    attr_reader :http2_error_type
+
+    def initialize(type, message = nil)
+      @http2_error_type = type
+      super(message)
+    end
+
+    def http2_error_code
+      ERROR_CODES[@http2_error_type]
+    end
+  end
+  class ConnectionError < HTTPError; end
+  class StreamError < HTTPError; end
+end

data/lib/plum/event_emitter.rb

@@ -0,0 +1,19 @@
+module Plum
+  module EventEmitter
+    # Registers an event handler to specified event. An event can have multiple handlers.
+    # @param name [String] The name of event.
+    # @yield Gives event-specific parameters.
+    def on(name, &blk)
+      callbacks[name] << blk
+    end
+
+    private
+    def callback(name, *args)
+      callbacks[name].each {|cb| cb.call(*args) }
+    end
+
+    def callbacks
+      @callbacks ||= Hash.new {|hash, key| hash[key] = [] }
+    end
+  end
+end

data/lib/plum/flow_control.rb

@@ -0,0 +1,97 @@
+using Plum::BinaryString
+
+module Plum
+  module FlowControl
+    attr_reader :send_remaining_window, :recv_remaining_window
+
+    # Sends frame respecting inner-stream flow control.
+    #
+    # @param frame [Frame] The frame to be sent.
+    def send(frame)
+      case frame.type
+      when :data
+        @send_buffer << frame
+        callback(:send_deferred, frame) if @send_remaining_window < frame.length
+        consume_send_buffer
+      else
+        send_immediately frame
+      end
+    end
+
+    # Increases receiving window size. Sends WINDOW_UPDATE frame to the peer.
+    #
+    # @param wsi [Integer] The amount to increase receiving window size. The legal range is 1 to 2^32-1.
+    def window_update(wsi)
+      @recv_remaining_window += wsi
+      payload = "".push_uint32(wsi & ~(1 << 31))
+      sid = (Stream === self) ? self.id : 0
+      send_immediately Frame.new(type: :window_update, stream_id: sid, payload: payload)
+    end
+
+    protected
+    def update_send_initial_window_size(diff)
+      @send_remaining_window += diff
+      consume_send_buffer
+
+      if Connection === self
+        @streams.values.each do |stream|
+          stream.update_send_initial_window_size(diff)
+        end
+      end
+    end
+
+    def update_recv_initial_window_size(diff)
+      @recv_remaining_window += diff
+      if Connection === self
+        @streams.values.each do |stream|
+          stream.update_recv_initial_window_size(diff)
+        end
+      end
+    end
+
+    private
+    def initialize_flow_control(send:, recv:)
+      @send_buffer = []
+      @send_remaining_window = send
+      @recv_remaining_window = recv
+    end
+
+    def consume_recv_window(frame)
+      case frame.type
+      when :data
+        @recv_remaining_window -= frame.length
+        if @recv_remaining_window < 0
+          local_error = (Connection === self) ? ConnectionError : StreamError
+          raise local_error.new(:flow_control_error)
+        end
+      end
+    end
+
+    def consume_send_buffer
+      while frame = @send_buffer.first
+        break if frame.length > @send_remaining_window
+        @send_buffer.shift
+        @send_remaining_window -= frame.length
+        send_immediately frame
+      end
+    end
+
+    def receive_window_update(frame)
+      if frame.length != 4
+        raise Plum::ConnectionError.new(:frame_size_error)
+      end
+
+      r_wsi = frame.payload.uint32
+      r = r_wsi >> 31
+      wsi = r_wsi & ~(1 << 31)
+
+      if wsi == 0
+        local_error = (Connection === self) ? ConnectionError : StreamError
+        raise local_error.new(:protocol_error)
+      end
+
+      @send_remaining_window += wsi
+      consume_send_buffer
+    end
+  end
+end