ruby-object-framework 1.0.0

data/lib/object_framework/http2/connection.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module ObjectFramework
+  module HTTP2
+    Stream = Struct.new(:id, :context, :input, :send_window, :receive_window,
+                        :remote_closed, :local_closed, :reset, :received, :content_length,
+                        keyword_init: true)
+
+    class Connection
+      PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".b.freeze
+      MAX_WINDOW = 2**31 - 1
+      attr_reader :io
+
+      def initialize(io:, on_stream:, reporter:, header_limit: 32 * 1024,
+                     stream_limit: 128, idle_timeout: 30, write_timeout: 30,
+                     tls: false)
+        @io, @on_stream, @reporter = io, on_stream, reporter
+        @header_limit, @stream_limit, @idle_timeout, @write_timeout, @tls = header_limit, stream_limit, idle_timeout, write_timeout, tls
+        @reader = HTTP::Reader.new(io:)
+        @decoder, @encoder = HPACK::Decoder.new(header_limit:), HPACK::Encoder.new
+        @mutex, @write_mutex, @changed = Mutex.new, Mutex.new, ConditionVariable.new
+        @streams, @last_stream, @closed, @draining = {}, 0, false, false
+        @peer_initial_window, @send_window, @receive_window = 65_535, 65_535, 65_535
+        @peer_frame_size, @continuation, @first_frame = 16_384, nil, true
+        @context = ExecutionContext.new
+      end
+
+      def run
+        handshake if @tls
+        raise ProtocolError, "Invalid HTTP/2 connection preface" unless @reader.read_exact(PREFACE.bytesize, deadline: deadline) == PREFACE
+        send_frame(4, 0, 0, [3, @stream_limit, 6, @header_limit].pack("nNnN"))
+        loop do
+          frame = Frame.read(@reader, deadline:)
+          if @first_frame
+            raise ProtocolError unless frame.type == 4 && frame.stream_id.zero? && (frame.flags & 1).zero?
+            @first_frame = false
+          end
+          raise ProtocolError if @continuation && (frame.type != 9 || frame.stream_id != @continuation[:id])
+          begin
+            process(frame)
+          rescue StreamError => error
+            reject_stream(error)
+          end
+        end
+      rescue EOFError, IOError, SystemCallError
+        nil
+      rescue StandardError => error
+        @reporter.report(error, context: @context)
+        begin
+          code = error.is_a?(ProtocolError) ? error.code : 2
+          send_frame(7, 0, 0, [@last_stream, code].pack("NN"))
+        rescue StandardError
+          nil
+        end
+      ensure
+        close
+      end
+
+      def close
+        streams = @mutex.synchronize do
+          @closed = true
+          @changed.broadcast
+          @streams.values.dup
+        end
+        streams.each { |stream| stream.input.cancel }
+        io.close unless io.closed?
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def send_headers(stream, headers, end_stream: false)
+        stream.context.cancellation.check! unless end_stream
+        block = @encoder.encode(headers)
+        raise CapacityExceeded, "Outgoing headers exceed configured limit" if headers.sum { |name, value| name.bytesize + value.bytesize + 32 } > @header_limit
+        @write_mutex.synchronize do
+          offset, first = 0, true
+          begin
+            chunk = block.byteslice(offset, @peer_frame_size) || "".b
+            offset += chunk.bytesize
+            flags = offset == block.bytesize ? 4 : 0
+            flags |= 1 if first && end_stream
+            write_frame(first ? 1 : 9, flags, stream.id, chunk)
+            first = false
+          end while offset < block.bytesize
+        end
+        finish_local(stream) if end_stream
+      end
+
+      def send_data(stream, bytes)
+        offset = 0
+        while offset < bytes.bytesize
+          count = @mutex.synchronize do
+            loop do
+              stream.context.cancellation.check!
+              raise Cancelled, "HTTP/2 stream is closed" if @closed || stream.reset || stream.local_closed
+              available = [@send_window, stream.send_window, @peer_frame_size, bytes.bytesize - offset].min
+              if available.positive?
+                @send_window -= available
+                stream.send_window -= available
+                break available
+              end
+              remaining = stream.context.cancellation.deadline ? stream.context.cancellation.deadline - HTTP::Timing.now : 0.1
+              @changed.wait(@mutex, [[remaining, 0].max, 0.1].min)
+            end
+          end
+          send_frame(0, 0, stream.id, bytes.byteslice(offset, count))
+          offset += count
+        end
+      end
+
+      def reset?(stream)
+        @mutex.synchronize { @closed || stream.reset }
+      end
+
+      private
+
+      def deadline; HTTP::Timing.now + @idle_timeout; end
+
+      def handshake
+        limit = deadline
+        loop do
+          result = io.accept_nonblock(exception: false)
+          break unless %i[wait_readable wait_writable].include?(result)
+          HTTP::Timing.wait(io, result == :wait_readable ? :read : :write, limit)
+        end
+        raise ProtocolError, "TLS must negotiate h2" unless io.alpn_protocol == "h2"
+      end
+
+      def process(frame)
+        case frame.type
+        when 0 then receive_data(frame)
+        when 1 then receive_headers(frame)
+        when 2
+          require_stream(frame)
+          require_size(frame, 5)
+          raise ProtocolError if frame.payload.unpack1("N") & MAX_WINDOW == frame.stream_id
+        when 3 then receive_reset(frame)
+        when 4 then receive_settings(frame)
+        when 5 then raise ProtocolError, "Clients cannot push streams"
+        when 6
+          require_connection(frame)
+          require_size(frame, 8)
+          send_frame(6, 1, 0, frame.payload) if (frame.flags & 1).zero?
+        when 7
+          require_connection(frame)
+          raise ProtocolError.new(code: 6) if frame.payload.bytesize < 8
+          @draining = true
+        when 8 then receive_window(frame)
+        when 9 then receive_continuation(frame)
+        end
+      end
+
+      def receive_settings(frame)
+        require_connection(frame)
+        if (frame.flags & 1).positive?
+          require_size(frame, 0)
+          return
+        end
+        raise ProtocolError.new(code: 6) unless (frame.payload.bytesize % 6).zero?
+        frame.payload.unpack("nN" * (frame.payload.bytesize / 6)).each_slice(2) do |id, value|
+          case id
+          when 2 then raise ProtocolError unless value <= 1
+          when 4
+            raise ProtocolError.new(code: 3) if value > MAX_WINDOW
+            @mutex.synchronize do
+              difference = value - @peer_initial_window
+              @streams.each_value do |stream|
+                raise ProtocolError.new(code: 3) if stream.send_window + difference > MAX_WINDOW
+                stream.send_window += difference
+              end
+              @peer_initial_window = value
+              @changed.broadcast
+            end
+          when 5
+            raise ProtocolError unless value.between?(16_384, 16_777_215)
+            @peer_frame_size = value
+          end
+        end
+        send_frame(4, 1, 0, "".b)
+      end
+
+      def receive_headers(frame)
+        require_stream(frame)
+        stream = @mutex.synchronize { @streams[frame.stream_id] }
+        fresh = !stream
+        if fresh
+          raise ProtocolError unless frame.stream_id.odd? && frame.stream_id > @last_stream && !@draining
+          @last_stream = frame.stream_id
+        else
+          raise StreamError.new(frame.stream_id, code: 5) if stream.remote_closed
+          raise StreamError.new(frame.stream_id) if (frame.flags & 1).zero?
+        end
+        payload, = unpad(frame)
+        if (frame.flags & 32).positive?
+          raise ProtocolError.new(code: 6) if payload.bytesize < 5
+          raise ProtocolError if payload.unpack1("N") & MAX_WINDOW == frame.stream_id
+          payload = payload.byteslice(5..)
+        end
+        @continuation = { id: frame.stream_id, bytes: payload, end_stream: (frame.flags & 1).positive?, fresh: }
+        complete_headers if (frame.flags & 4).positive?
+      end
+
+      def receive_continuation(frame)
+        raise ProtocolError unless @continuation && @continuation[:id] == frame.stream_id
+        @continuation[:bytes] += frame.payload
+        raise CompressionError if @continuation[:bytes].bytesize > @header_limit
+        complete_headers if (frame.flags & 4).positive?
+      end
+
+      def complete_headers
+        block, @continuation = @continuation, nil
+        headers = @decoder.decode(block[:bytes])
+        begin
+          validate_headers(headers, request: block[:fresh])
+        rescue ProtocolError => error
+          raise StreamError.new(block[:id], error.message, code: error.code)
+        end
+        if block[:fresh]
+          context = ExecutionContext.new
+          stream = Stream.new(id: block[:id], context:, send_window: @peer_initial_window,
+            receive_window: 65_535, remote_closed: block[:end_stream], local_closed: false,
+            reset: false, received: 0, content_length: nil)
+          stream.input = Inbound.new(cancellation: context.cancellation,
+            on_consume: ->(count) { release_capacity(stream, count) })
+          lengths = headers.select { |name, _| name == "content-length" }.map(&:last)
+          unless lengths.empty?
+            raise ProtocolError unless lengths.size == 1 && /\A[0-9]+\z/.match?(lengths.first)
+            stream.content_length = Integer(lengths.first, 10)
+          end
+          @mutex.synchronize do
+            raise StreamError.new(stream.id, "Peer exceeded concurrent stream limit", code: 7) if @streams.size >= @stream_limit
+            @streams[stream.id] = stream
+          end
+          finish_remote(stream) if block[:end_stream]
+          @on_stream.call(self, stream, headers)
+        else
+          stream = @mutex.synchronize { @streams.fetch(block[:id]) }
+          finish_remote(stream)
+        end
+      end
+
+      def validate_headers(headers, request:)
+        regular, pseudo = false, {}
+        headers.each do |name, value|
+          raise ProtocolError unless /\A:?[!#$%&'*+.^_`|~0-9a-z-]+\z/.match?(name)
+          raise ProtocolError if value.match?(/[\x00\r\n]/) || value.start_with?(" ", "\t") || value.end_with?(" ", "\t")
+          if name.start_with?(":")
+            raise ProtocolError if regular || !request || pseudo.key?(name) || !%w[:method :path :scheme :authority].include?(name)
+            pseudo[name] = value
+          else
+            regular = true
+            raise ProtocolError if %w[connection keep-alive proxy-connection transfer-encoding upgrade].include?(name)
+            raise ProtocolError if name == "te" && value != "trailers"
+          end
+        end
+        if request
+          raise ProtocolError unless pseudo[":method"] && %w[http https].include?(pseudo[":scheme"]) && pseudo[":path"]&.start_with?("/")
+        end
+      end
+
+      def receive_data(frame)
+        require_stream(frame)
+        payload, overhead = unpad(frame)
+        stream = @mutex.synchronize do
+          @receive_window -= frame.payload.bytesize
+          raise ProtocolError.new(code: 3) if @receive_window.negative?
+          @streams[frame.stream_id]
+        end
+        unless stream
+          raise ProtocolError if frame.stream_id > @last_stream
+          release_capacity(nil, frame.payload.bytesize)
+          send_frame(3, 0, frame.stream_id, [5].pack("N"))
+          return
+        end
+        if stream.remote_closed
+          release_capacity(nil, frame.payload.bytesize)
+          raise StreamError.new(stream.id, "DATA after end of stream", code: 5)
+        end
+        exceeded = false
+        @mutex.synchronize do
+          stream.receive_window -= frame.payload.bytesize
+          exceeded = stream.receive_window.negative?
+          stream.received += payload.bytesize
+        end
+        if exceeded
+          release_capacity(nil, frame.payload.bytesize)
+          raise StreamError.new(stream.id, code: 3)
+        end
+        release_capacity(stream, overhead) if overhead.positive?
+        stream.input.push(payload)
+        finish_remote(stream) if (frame.flags & 1).positive?
+      end
+
+      def receive_reset(frame)
+        require_stream(frame)
+        require_size(frame, 4)
+        stream = @mutex.synchronize do
+          raise ProtocolError if frame.stream_id > @last_stream
+          found = @streams.delete(frame.stream_id)
+          found.reset = true if found
+          @changed.broadcast
+          found
+        end
+        stream&.input&.cancel
+        stream&.input&.discard
+      end
+
+      def receive_window(frame)
+        require_size(frame, 4)
+        increment = frame.payload.unpack1("N") & MAX_WINDOW
+        if increment.zero?
+          raise ProtocolError if frame.stream_id.zero?
+          raise StreamError.new(frame.stream_id)
+        end
+        @mutex.synchronize do
+          if frame.stream_id.zero?
+            raise ProtocolError.new(code: 3) if @send_window + increment > MAX_WINDOW
+            @send_window += increment
+          elsif (stream = @streams[frame.stream_id])
+            raise StreamError.new(stream.id, code: 3) if stream.send_window + increment > MAX_WINDOW
+            stream.send_window += increment
+          elsif frame.stream_id > @last_stream
+            raise ProtocolError
+          end
+          @changed.broadcast
+        end
+      end
+
+      def finish_remote(stream)
+        if stream.content_length && stream.received != stream.content_length
+          raise StreamError.new(stream.id, "Content length does not match DATA")
+        end
+        @mutex.synchronize do
+          stream.remote_closed = true
+          @streams.delete(stream.id) if stream.local_closed
+        end
+        stream.input.finish
+      end
+
+      def finish_local(stream)
+        @mutex.synchronize do
+          stream.local_closed = true
+          @streams.delete(stream.id) if stream.remote_closed
+          @changed.broadcast
+        end
+        stream.input.discard
+      end
+
+      def release_capacity(stream, count)
+        return if count.zero?
+        active_stream = @mutex.synchronize do
+          return if @closed
+          @receive_window += count
+          if stream && @streams.key?(stream.id) && !stream.reset
+            stream.receive_window += count
+            true
+          end
+        end
+        send_frame(8, 0, 0, [count].pack("N"))
+        send_frame(8, 0, stream.id, [count].pack("N")) if active_stream
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def reject_stream(error)
+        stream = @mutex.synchronize do
+          found = @streams.delete(error.stream_id)
+          found.reset = true if found
+          @changed.broadcast
+          found
+        end
+        @reporter.report(error, context: stream&.context || ExecutionContext.new)
+        stream&.input&.cancel
+        stream&.input&.discard
+        send_frame(3, 0, error.stream_id, [error.code].pack("N"))
+      end
+
+      def unpad(frame)
+        return [frame.payload, 0] if (frame.flags & 8).zero?
+        padding = frame.payload.getbyte(0)
+        raise ProtocolError unless padding && padding < frame.payload.bytesize
+        [frame.payload.byteslice(1, frame.payload.bytesize - padding - 1), padding + 1]
+      end
+
+      def require_connection(frame); raise ProtocolError unless frame.stream_id.zero?; end
+      def require_stream(frame); raise ProtocolError if frame.stream_id.zero?; end
+      def require_size(frame, size); raise ProtocolError.new(code: 6) unless frame.payload.bytesize == size; end
+
+      def send_frame(type, flags, stream_id, payload)
+        @write_mutex.synchronize { write_frame(type, flags, stream_id, payload) }
+      end
+
+      def write_frame(type, flags, stream_id, payload)
+        frame = Frame.new(type:, flags:, stream_id:, payload:)
+        @reader.write(frame.encode, deadline: HTTP::Timing.now + @write_timeout)
+      end
+    end
+  end
+end

data/lib/object_framework/http2/frame.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ObjectFramework
+  module HTTP2
+    Frame = Data.define(:type, :flags, :stream_id, :payload) do
+      def encode
+        raise ProtocolError, "Frame is too large" if payload.bytesize > 16_777_215
+        length = [payload.bytesize].pack("N").byteslice(1, 3)
+        length + [type, flags, stream_id & 0x7fff_ffff].pack("CCN") + payload.b
+      end
+
+      def self.read(reader, deadline:, max_size: 16_384)
+        header = reader.read_exact(9, deadline:)
+        length = ("\x00".b + header.byteslice(0, 3)).unpack1("N")
+        raise ProtocolError.new("Frame exceeds advertised size", code: 6) if length > max_size
+        type, flags, stream_id = header.byteslice(3, 6).unpack("CCN")
+        new(type:, flags:, stream_id: stream_id & 0x7fff_ffff, payload: reader.read_exact(length, deadline:))
+      end
+    end
+  end
+end

data/lib/object_framework/http2/hpack.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require_relative "hpack_tables"
+
+module ObjectFramework
+  module HTTP2
+    class ProtocolError < StandardError
+      attr_reader :code
+      def initialize(message = "HTTP/2 protocol error", code: 1)
+        super(message)
+        @code = code
+      end
+    end
+    class CompressionError < ProtocolError
+      def initialize(message = "Invalid HPACK block"); super(message, code: 9); end
+    end
+    class StreamError < ProtocolError
+      attr_reader :stream_id
+      def initialize(stream_id, message = "Invalid HTTP/2 stream", code: 1)
+        super(message, code:)
+        @stream_id = stream_id
+      end
+    end
+
+    module HPACK
+      module Huffman
+        TREE = begin
+          root = {}
+          HUFFMAN_CODES.each_with_index do |(code, length), symbol|
+            node = root
+            (length - 1).downto(0) { |bit| node = (node[(code >> bit) & 1] ||= {}) }
+            node[:symbol] = symbol
+          end
+          freeze_tree = ->(node) { node.each_value { |value| freeze_tree.call(value) if value.is_a?(Hash) }; node.freeze }
+          freeze_tree.call(root)
+        end
+
+        def self.encode(bytes)
+          output, bits, length = +"".b, 0, 0
+          bytes.each_byte do |byte|
+            code, size = HUFFMAN_CODES.fetch(byte)
+            bits, length = (bits << size) | code, length + size
+            while length >= 8
+              length -= 8
+              output << ((bits >> length) & 255)
+            end
+            bits &= (1 << length) - 1
+          end
+          output << ((bits << (8 - length)) | ((1 << (8 - length)) - 1)) if length.positive?
+          output
+        end
+
+        def self.decode(bytes, limit: 32 * 1024)
+          output, node, tail, tail_size = +"".b, TREE, 0, 0
+          bytes.each_byte do |byte|
+            7.downto(0) do |index|
+              bit = (byte >> index) & 1
+              node = node[bit] || raise(CompressionError)
+              tail, tail_size = (tail << 1) | bit, tail_size + 1
+              if (symbol = node[:symbol])
+                raise CompressionError if symbol == 256 || output.bytesize >= limit
+                output << symbol
+                node, tail, tail_size = TREE, 0, 0
+              end
+            end
+          end
+          raise CompressionError if tail_size > 7 || tail != (1 << tail_size) - 1
+          output
+        end
+      end
+
+      module IntegerCoding
+        def self.encode(number, prefix:, mask: 0)
+          maximum = (1 << prefix) - 1
+          return [mask | number].pack("C") if number < maximum
+          bytes, number = [mask | maximum].pack("C"), number - maximum
+          while number >= 128
+            bytes << ((number & 127) | 128)
+            number >>= 7
+          end
+          bytes << number
+        end
+      end
+
+      class Cursor
+        def initialize(bytes); @bytes, @offset = bytes.b, 0; end
+        def done?; @offset == @bytes.bytesize; end
+        def peek; @bytes.getbyte(@offset) || raise(CompressionError); end
+
+        def take(count)
+          raise CompressionError if count.negative? || @offset + count > @bytes.bytesize
+          result = @bytes.byteslice(@offset, count)
+          @offset += count
+          result
+        end
+
+        def integer(prefix)
+          maximum = (1 << prefix) - 1
+          value = take(1).getbyte(0) & maximum
+          return value if value < maximum
+          9.times do |index|
+            byte = take(1).getbyte(0)
+            value += (byte & 127) << (index * 7)
+            raise CompressionError if value > 2**63 - 1
+            return value if byte < 128
+          end
+          raise CompressionError
+        end
+
+        def string(limit:)
+          huffman = (peek & 128).positive?
+          length = integer(7)
+          value = take(length)
+          value = Huffman.decode(value, limit:) if huffman
+          raise CompressionError if value.bytesize > limit
+          value
+        end
+      end
+
+      class Decoder
+        def initialize(table_limit: 4096, header_limit: 32 * 1024)
+          @maximum, @capacity, @header_limit = table_limit, table_limit, header_limit
+          @dynamic, @size = [], 0
+        end
+
+        def decode(bytes)
+          cursor, headers, total, saw_header = Cursor.new(bytes), [], 0, false
+          until cursor.done?
+            first = cursor.peek
+            if (first & 128).positive?
+              pair = lookup(cursor.integer(7))
+            elsif (first & 224) == 32
+              raise CompressionError if saw_header
+              capacity = cursor.integer(5)
+              raise CompressionError if capacity > @maximum
+              @capacity = capacity
+              evict
+              next
+            else
+              indexed = (first & 64).positive?
+              index = cursor.integer(indexed ? 6 : 4)
+              name = index.zero? ? cursor.string(limit: @header_limit - total) : lookup(index).first
+              value = cursor.string(limit: @header_limit - total)
+              pair = [name.freeze, value.freeze].freeze
+              add(pair) if indexed
+            end
+            total += entry_size(pair)
+            raise CompressionError if total > @header_limit
+            headers << pair
+            saw_header = true
+          end
+          headers.freeze
+        end
+
+        private
+
+        def lookup(index)
+          raise CompressionError if index.zero?
+          (index <= STATIC_TABLE.size ? STATIC_TABLE[index - 1] : @dynamic[index - STATIC_TABLE.size - 1]) || raise(CompressionError)
+        end
+
+        def entry_size(pair); pair[0].bytesize + pair[1].bytesize + 32; end
+
+        def add(pair)
+          size = entry_size(pair)
+          if size > @capacity
+            @dynamic.clear
+            @size = 0
+          else
+            @dynamic.unshift(pair)
+            @size += size
+            evict
+          end
+        end
+
+        def evict
+          @size -= entry_size(@dynamic.pop) while @size > @capacity
+        end
+      end
+
+      class Encoder
+        def encode(headers)
+          headers.map do |name, value|
+            name, value = name.to_s.b, value.to_s.b
+            exact = STATIC_TABLE.index([name, value])
+            if exact
+              IntegerCoding.encode(exact + 1, prefix: 7, mask: 128)
+            else
+              index = STATIC_TABLE.index { |pair| pair.first == name }
+              # Never index application metadata, including credentials and operation IDs.
+              prefix = IntegerCoding.encode(index ? index + 1 : 0, prefix: 4, mask: 16)
+              prefix += string(name) unless index
+              prefix + string(value)
+            end
+          end.join.b
+        end
+
+        private
+
+        def string(bytes)
+          IntegerCoding.encode(bytes.bytesize, prefix: 7) + bytes
+        end
+      end
+    end
+  end
+end