http-2-next 0.2.6 → 0.3.0

data/lib/http/2/next/header/decompressor.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module HTTP2Next
+  module Header
+    # Responsible for decoding received headers and maintaining compression
+    # context of the opposing peer. Decompressor must be initialized with
+    # appropriate starting context based on local role: client or server.
+    #
+    # @example
+    #   server_role = Decompressor.new(:request)
+    #   client_role = Decompressor.new(:response)
+    class Decompressor
+      include Error
+
+      # @param options [Hash] decoding options.  Only :table_size is effective.
+      def initialize(options = {})
+        @cc = EncodingContext.new(options)
+      end
+
+      # Set dynamic table size in EncodingContext
+      # @param size [Integer] new dynamic table size
+      def table_size=(size)
+        @cc.table_size = size
+      end
+
+      # Decodes integer value from provided buffer.
+      #
+      # @param buf [String]
+      # @param n [Integer] number of available bits
+      # @return [Integer]
+      def integer(buf, n)
+        limit = 2**n - 1
+        i = !n.zero? ? (buf.getbyte & limit) : 0
+
+        m = 0
+        if i == limit
+          while (byte = buf.getbyte)
+            i += ((byte & 127) << m)
+            m += 7
+
+            break if (byte & 128).zero?
+          end
+        end
+
+        i
+      end
+
+      # Decodes string value from provided buffer.
+      #
+      # @param buf [String]
+      # @return [String] UTF-8 encoded string
+      # @raise [CompressionError] when input is malformed
+      def string(buf)
+        raise CompressionError, "invalid header block fragment" if buf.empty?
+
+        huffman = (buf.readbyte(0) & 0x80) == 0x80
+        len = integer(buf, 7)
+        str = buf.read(len)
+        raise CompressionError, "string too short" unless str.bytesize == len
+
+        str = Huffman.new.decode(Buffer.new(str)) if huffman
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      # Decodes header command from provided buffer.
+      #
+      # @param buf [Buffer]
+      # @return [Hash] command
+      def header(buf)
+        peek = buf.readbyte(0)
+
+        header = {}
+        header[:type], type = HEADREP.find do |_t, desc|
+          mask = (peek >> desc[:prefix]) << desc[:prefix]
+          mask == desc[:pattern]
+        end
+
+        raise CompressionError unless header[:type]
+
+        header[:name] = integer(buf, type[:prefix])
+
+        case header[:type]
+        when :indexed
+          raise CompressionError if (header[:name]).zero?
+
+          header[:name] -= 1
+        when :changetablesize
+          header[:value] = header[:name]
+        else
+          if (header[:name]).zero?
+            header[:name] = string(buf)
+          else
+            header[:name] -= 1
+          end
+          header[:value] = string(buf)
+        end
+
+        header
+      end
+
+      FORBIDDEN_HEADERS = %w[connection te].freeze
+
+      # Decodes and processes header commands within provided buffer.
+      #
+      # @param buf [Buffer]
+      # @param frame [HTTP2Next::Frame, nil]
+      # @return [Array] +[[name, value], ...]
+      def decode(buf, frame = nil)
+        list = []
+        decoding_pseudo_headers = true
+        @cc.listen_on_table do
+          until buf.empty?
+            field, value = @cc.process(header(buf))
+            next if field.nil?
+
+            is_pseudo_header = field.start_with? ":"
+            if !decoding_pseudo_headers && is_pseudo_header
+              raise ProtocolError, "one or more pseudo headers encountered after regular headers"
+            end
+
+            decoding_pseudo_headers = is_pseudo_header
+            raise ProtocolError, "invalid header received: #{field}" if FORBIDDEN_HEADERS.include?(field)
+
+            if frame
+              case field
+              when ":method"
+                frame[:method] = value
+              when "content-length"
+                frame[:content_length] = Integer(value)
+              when "trailer"
+                (frame[:trailer] ||= []) << value
+              end
+            end
+            list << [field, value]
+          end
+        end
+        list
+      end
+    end
+  end
+end

data/lib/http/2/next/{compressor.rb → header/encoding_context.rb}

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
 
 module HTTP2Next
-  # 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
+  # To decompress header blocks, a decoder only needs to maintain a
+  # dynamic table as a decoding context.
+  # No other state information is needed.
   module Header
-    # To decompress header blocks, a decoder only needs to maintain a
-    # dynamic table as a decoding context.
-    # No other state information is needed.
     class EncodingContext
       include Error
 
-      using Extensions
+      using RegexpExtensions
 
       UPPER = /[[:upper:]]/.freeze
 
@@ -185,14 +181,15 @@ module HTTP2Next
           # o  The header field is added to the decoded header list.
           # o  The header field is inserted at the beginning of the dynamic table.
 
-          if cmd[:name].is_a? Integer
+          case cmd[:name]
+          when Integer
             k, v = dereference(cmd[:name])
 
             cmd = cmd.dup
             cmd[:index] ||= cmd[:name]
             cmd[:value] ||= v
             cmd[:name] = k
-          elsif UPPER.match?(cmd[:name])
+          when UPPER
             raise ProtocolError, "Invalid uppercase key: #{cmd[:name]}"
           end
 
@@ -329,293 +326,5 @@ module HTTP2Next
         cmdsize <= @limit
       end
     end
-
-    # 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
-
-    # Responsible for encoding header key-value pairs using HPACK algorithm.
-    class Compressor
-      # @param options [Hash] encoding options
-      def initialize(options = {})
-        @cc = EncodingContext.new(options)
-      end
-
-      # Set dynamic table size in EncodingContext
-      # @param size [Integer] new dynamic table size
-      def table_size=(size)
-        @cc.table_size = size
-      end
-
-      # Encodes provided value via integer representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.1
-      #
-      #  If I < 2^N - 1, encode I on N bits
-      #  Else
-      #      encode 2^N - 1 on N bits
-      #      I = I - (2^N - 1)
-      #      While I >= 128
-      #           Encode (I % 128 + 128) on 8 bits
-      #           I = I / 128
-      #      encode (I) on 8 bits
-      #
-      # @param i [Integer] value to encode
-      # @param n [Integer] number of available bits
-      # @return [String] binary string
-      def integer(i, n)
-        limit = 2**n - 1
-        return [i].pack("C") if i < limit
-
-        bytes = []
-        bytes.push limit unless n.zero?
-
-        i -= limit
-        while i >= 128
-          bytes.push((i % 128) + 128)
-          i /= 128
-        end
-
-        bytes.push i
-        bytes.pack("C*")
-      end
-
-      # Encodes provided value via string literal representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.2
-      #
-      # * The string length, defined as the number of bytes needed to store
-      #   its UTF-8 representation, is represented as an integer with a seven
-      #   bits prefix. If the string length is strictly less than 127, it is
-      #   represented as one byte.
-      # * If the bit 7 of the first byte is 1, the string value is represented
-      #   as a list of Huffman encoded octets
-      #   (padded with bit 1's until next octet boundary).
-      # * If the bit 7 of the first byte is 0, the string value is
-      #   represented as a list of UTF-8 encoded octets.
-      #
-      # +@options [:huffman]+ controls whether to use Huffman encoding:
-      #  :never   Do not use Huffman encoding
-      #  :always  Always use Huffman encoding
-      #  :shorter Use Huffman when the result is strictly shorter
-      #
-      # @param str [String]
-      # @return [String] binary string
-      def string(str)
-        plain = nil
-        huffman = nil
-        plain = integer(str.bytesize, 7) << str.dup.force_encoding(Encoding::BINARY) unless @cc.options[:huffman] == :always
-        unless @cc.options[:huffman] == :never
-          huffman = Huffman.new.encode(str)
-          huffman = integer(huffman.bytesize, 7) << huffman
-          huffman.setbyte(0, huffman.ord | 0x80)
-        end
-        case @cc.options[:huffman]
-        when :always
-          huffman
-        when :never
-          plain
-        else
-          huffman.bytesize < plain.bytesize ? huffman : plain
-        end
-      end
-
-      # Encodes header command with appropriate header representation.
-      #
-      # @param h [Hash] header command
-      # @param buffer [String]
-      # @return [Buffer]
-      def header(h, buffer = Buffer.new)
-        rep = HEADREP[h[:type]]
-
-        case h[:type]
-        when :indexed
-          buffer << integer(h[:name] + 1, rep[:prefix])
-        when :changetablesize
-          buffer << integer(h[:value], rep[:prefix])
-        else
-          if h[:name].is_a? Integer
-            buffer << integer(h[:name] + 1, rep[:prefix])
-          else
-            buffer << integer(0, rep[:prefix])
-            buffer << string(h[:name])
-          end
-
-          buffer << string(h[:value])
-        end
-
-        # set header representation pattern on first byte
-        fb = buffer.ord | rep[:pattern]
-        buffer.setbyte(0, fb)
-
-        buffer
-      end
-
-      # Encodes provided list of HTTP headers.
-      #
-      # @param headers [Array] +[[name, value], ...]+
-      # @return [Buffer]
-      def encode(headers)
-        buffer = Buffer.new
-        pseudo_headers, regular_headers = headers.partition { |f, _| f.start_with? ":" }
-        headers = [*pseudo_headers, *regular_headers]
-        commands = @cc.encode(headers)
-        commands.each do |cmd|
-          buffer << header(cmd)
-        end
-
-        buffer
-      end
-    end
-
-    # Responsible for decoding received headers and maintaining compression
-    # context of the opposing peer. Decompressor must be initialized with
-    # appropriate starting context based on local role: client or server.
-    #
-    # @example
-    #   server_role = Decompressor.new(:request)
-    #   client_role = Decompressor.new(:response)
-    class Decompressor
-      include Error
-
-      # @param options [Hash] decoding options.  Only :table_size is effective.
-      def initialize(options = {})
-        @cc = EncodingContext.new(options)
-      end
-
-      # Set dynamic table size in EncodingContext
-      # @param size [Integer] new dynamic table size
-      def table_size=(size)
-        @cc.table_size = size
-      end
-
-      # Decodes integer value from provided buffer.
-      #
-      # @param buf [String]
-      # @param n [Integer] number of available bits
-      # @return [Integer]
-      def integer(buf, n)
-        limit = 2**n - 1
-        i = !n.zero? ? (buf.getbyte & limit) : 0
-
-        m = 0
-        if i == limit
-          while (byte = buf.getbyte)
-            i += ((byte & 127) << m)
-            m += 7
-
-            break if (byte & 128).zero?
-          end
-        end
-
-        i
-      end
-
-      # Decodes string value from provided buffer.
-      #
-      # @param buf [String]
-      # @return [String] UTF-8 encoded string
-      # @raise [CompressionError] when input is malformed
-      def string(buf)
-        raise CompressionError, "invalid header block fragment" if buf.empty?
-
-        huffman = (buf.readbyte(0) & 0x80) == 0x80
-        len = integer(buf, 7)
-        str = buf.read(len)
-        raise CompressionError, "string too short" unless str.bytesize == len
-
-        str = Huffman.new.decode(Buffer.new(str)) if huffman
-        str.force_encoding(Encoding::UTF_8)
-      end
-
-      # Decodes header command from provided buffer.
-      #
-      # @param buf [Buffer]
-      # @return [Hash] command
-      def header(buf)
-        peek = buf.readbyte(0)
-
-        header = {}
-        header[:type], type = HEADREP.find do |_t, desc|
-          mask = (peek >> desc[:prefix]) << desc[:prefix]
-          mask == desc[:pattern]
-        end
-
-        raise CompressionError unless header[:type]
-
-        header[:name] = integer(buf, type[:prefix])
-
-        case header[:type]
-        when :indexed
-          raise CompressionError if (header[:name]).zero?
-
-          header[:name] -= 1
-        when :changetablesize
-          header[:value] = header[:name]
-        else
-          if (header[:name]).zero?
-            header[:name] = string(buf)
-          else
-            header[:name] -= 1
-          end
-          header[:value] = string(buf)
-        end
-
-        header
-      end
-
-      FORBIDDEN_HEADERS = %w[connection te].freeze
-
-      # Decodes and processes header commands within provided buffer.
-      #
-      # @param buf [Buffer]
-      # @param frame [HTTP2Next::Frame, nil]
-      # @return [Array] +[[name, value], ...]
-      def decode(buf, frame = nil)
-        list = []
-        decoding_pseudo_headers = true
-        @cc.listen_on_table do
-          until buf.empty?
-            field, value = @cc.process(header(buf))
-            next if field.nil?
-
-            is_pseudo_header = field.start_with? ":"
-            if !decoding_pseudo_headers && is_pseudo_header
-              raise ProtocolError, "one or more pseudo headers encountered after regular headers"
-            end
-
-            decoding_pseudo_headers = is_pseudo_header
-            raise ProtocolError, "invalid header received: #{field}" if FORBIDDEN_HEADERS.include?(field)
-
-            if frame
-              case field
-              when ":method"
-                frame[:method] = value
-              when "content-length"
-                frame[:content_length] = Integer(value)
-              when "trailer"
-                (frame[:trailer] ||= []) << value
-              end
-            end
-            list << [field, value]
-          end
-        end
-        list
-      end
-    end
   end
 end