http-2 0.6.1 → 0.6.3

data/http-2.gemspec

@@ -19,6 +19,4 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
 end

data/lib/http/2.rb

@@ -6,4 +6,6 @@ require "http/2/flow_buffer"
 require "http/2/compressor"
 require "http/2/framer"
 require "http/2/connection"
+require "http/2/client"
+require "http/2/server"
 require "http/2/stream"

data/lib/http/2/buffer.rb

@@ -4,17 +4,34 @@ module HTTP2
   #
   class Buffer < String
 
+    UINT32 = "N"
+    BINARY = "binary"
+    private_constant :UINT32, :BINARY
+
     # Forces binary encoding on the string
-    def initialize(*args)
-      force_encoding('binary')
-      super(*args)
+    def initialize(data = '')
+      super(data.force_encoding(BINARY))
     end
 
     # Emulate StringIO#read: slice first n bytes from the buffer.
     #
     # @param n [Integer] number of bytes to slice from the buffer
     def read(n)
-      slice!(0,n)
+      Buffer.new(slice!(0,n))
+    end
+
+    # Alias getbyte to readbyte
+    alias :readbyte :getbyte
+
+    # Emulate StringIO#getbyte: slice first byte from buffer.
+    def getbyte
+      read(1).ord
+    end
+
+    # Slice unsigned 32-bit integer from buffer.
+    # @return [Integer]
+    def read_uint32
+      read(4).unpack(UINT32).first
     end
   end
 

data/lib/http/2/client.rb

@@ -0,0 +1,50 @@
+module HTTP2
+
+  # HTTP 2.0 client connection class that implements appropriate header
+  # compression / decompression algorithms and stream management logic.
+  #
+  # Your code is responsible for driving the client object, which in turn
+  # performs all of the necessary HTTP 2.0 encoding / decoding, state
+  # management, and the rest. A simple example:
+  #
+  # @example
+  #     socket = YourTransport.new
+  #
+  #     conn = HTTP2::Client.new
+  #     conn.on(:frame) {|bytes| socket << bytes }
+  #
+  #     while bytes = socket.read
+  #       conn << bytes
+  #     end
+  #
+  class Client < Connection
+
+    # Initialize new HTTP 2.0 client object.
+    def initialize(*args)
+      @stream_id    = 1
+      @state        = :connection_header
+      @compressor   = Header::Compressor.new(:request)
+      @decompressor = Header::Decompressor.new(:response)
+
+      super
+    end
+
+    # Send an outgoing frame. Connection and stream flow control is managed
+    # by Connection class.
+    #
+    # @see Connection
+    # @note Client will emit the connection header as the first 24 bytes
+    # @param frame [Hash]
+    def send(frame)
+      if @state == :connection_header
+        emit(:frame, CONNECTION_HEADER)
+        @state = :connected
+
+        settings(stream_limit: @stream_limit, window_limit: @window_limit)
+      end
+
+      super(frame)
+    end
+  end
+
+end

data/lib/http/2/compressor.rb

@@ -1,5 +1,3 @@
-require "stringio"
-
 module HTTP2
 
   # Implementation of header compression for HTTP 2.0 (HPACK) format adapted
@@ -12,97 +10,84 @@ module HTTP2
     # encoding context: an encoding context contains a header table and a
     # reference set - there is one encoding context for each direction.
     #
-    class CompressionContext
+    class EncodingContext
       include Error
 
       # TODO: replace StringIO with Buffer...
 
       # Default request working set as defined by the spec.
       REQ_DEFAULTS = [
-        [':scheme'            ,'http' ],
-        [':scheme'            ,'https'],
-        [':host'              ,''     ],
-        [':path'              ,'/'    ],
-        [':method'            ,'get'  ],
-        ['accept'             ,''     ],
-        ['accept-charset'     ,''     ],
-        ['accept-encoding'    ,''     ],
-        ['accept-language'    ,''     ],
-        ['cookie'             ,''     ],
-        ['if-modified-since'  ,''     ],
-        ['keep-alive'         ,''     ],
-        ['user-agent'         ,''     ],
-        ['proxy-connection'   ,''     ],
-        ['referer'            ,''     ],
-        ['accept-datetime'    ,''     ],
-        ['authorization'      ,''     ],
-        ['allow'              ,''     ],
-        ['cache-control'      ,''     ],
-        ['connection'         ,''     ],
-        ['content-length'     ,''     ],
-        ['content-md5'        ,''     ],
-        ['content-type'       ,''     ],
-        ['date'               ,''     ],
-        ['expect'             ,''     ],
-        ['from'               ,''     ],
-        ['if-match'           ,''     ],
-        ['if-none-match'      ,''     ],
-        ['if-range'           ,''     ],
-        ['if-unmodified-since',''     ],
-        ['max-forwards'       ,''     ],
-        ['pragma'             ,''     ],
-        ['proxy-authorization',''     ],
-        ['range'              ,''     ],
-        ['te'                 ,''     ],
-        ['upgrade'            ,''     ],
-        ['via'                ,''     ],
-        ['warning'            ,''     ]
-      ];
+        [':scheme'            , 'http' ],
+        [':scheme'            , 'https'],
+        [':host'              , ''     ],
+        [':path'              , '/'    ],
+        [':method'            , 'get'  ],
+        ['accept'             , ''     ],
+        ['accept-charset'     , ''     ],
+        ['accept-encoding'    , ''     ],
+        ['accept-language'    , ''     ],
+        ['cookie'             , ''     ],
+        ['if-modified-since'  , ''     ],
+        ['user-agent'         , ''     ],
+        ['referer'            , ''     ],
+        ['authorization'      , ''     ],
+        ['allow'              , ''     ],
+        ['cache-control'      , ''     ],
+        ['connection'         , ''     ],
+        ['content-length'     , ''     ],
+        ['content-type'       , ''     ],
+        ['date'               , ''     ],
+        ['expect'             , ''     ],
+        ['from'               , ''     ],
+        ['if-match'           , ''     ],
+        ['if-none-match'      , ''     ],
+        ['if-range'           , ''     ],
+        ['if-unmodified-since', ''     ],
+        ['max-forwards'       , ''     ],
+        ['proxy-authorization', ''     ],
+        ['range'              , ''     ],
+        ['via'                , ''     ]
+      ]
 
       # Default response working set as defined by the spec.
       RESP_DEFAULTS = [
-        [':status'                    ,'200'],
-        ['age'                        ,''   ],
-        ['cache-control'              ,''   ],
-        ['content-length'             ,''   ],
-        ['content-type'               ,''   ],
-        ['date'                       ,''   ],
-        ['etag'                       ,''   ],
-        ['expires'                    ,''   ],
-        ['last-modified'              ,''   ],
-        ['server'                     ,''   ],
-        ['set-cookie'                 ,''   ],
-        ['vary'                       ,''   ],
-        ['via'                        ,''   ],
-        ['access-control-allow-origin',''   ],
-        ['accept-ranges'              ,''   ],
-        ['allow'                      ,''   ],
-        ['connection'                 ,''   ],
-        ['content-disposition'        ,''   ],
-        ['content-encoding'           ,''   ],
-        ['content-language'           ,''   ],
-        ['content-location'           ,''   ],
-        ['content-md5'                ,''   ],
-        ['content-range'              ,''   ],
-        ['link'                       ,''   ],
-        ['location'                   ,''   ],
-        ['p3p'                        ,''   ],
-        ['pragma'                     ,''   ],
-        ['proxy-authenticate'         ,''   ],
-        ['refresh'                    ,''   ],
-        ['retry-after'                ,''   ],
-        ['strict-transport-security'  ,''   ],
-        ['trailer'                    ,''   ],
-        ['transfer-encoding'          ,''   ],
-        ['warning'                    ,''   ],
-        ['www-authenticate'           ,''   ]
-      ];
+        [':status'                     , '200'],
+        ['age'                         , ''   ],
+        ['cache-control'               , ''   ],
+        ['content-length'              , ''   ],
+        ['content-type'                , ''   ],
+        ['date'                        , ''   ],
+        ['etag'                        , ''   ],
+        ['expires'                     , ''   ],
+        ['last-modified'               , ''   ],
+        ['server'                      , ''   ],
+        ['set-cookie'                  , ''   ],
+        ['vary'                        , ''   ],
+        ['via'                         , ''   ],
+        ['access-control-allow-origin' , ''   ],
+        ['accept-ranges'               , ''   ],
+        ['allow'                       , ''   ],
+        ['connection'                  , ''   ],
+        ['content-disposition'         , ''   ],
+        ['content-encoding'            , ''   ],
+        ['content-language'            , ''   ],
+        ['content-location'            , ''   ],
+        ['content-range'               , ''   ],
+        ['link'                        , ''   ],
+        ['location'                    , ''   ],
+        ['proxy-authenticate'          , ''   ],
+        ['refresh'                     , ''   ],
+        ['retry-after'                 , ''   ],
+        ['strict-transport-security'   , ''   ],
+        ['transfer-encoding'           , ''   ],
+        ['www-authenticate'            , ''   ]
+      ]
 
       # Current table of header key-value pairs.
       attr_reader :table
 
-      # Current working set of header key-value pairs.
-      attr_reader :workset
+      # Current reference set of header key-value pairs.
+      attr_reader :refset
 
       # Initializes compression context with appropriate client/server
       # defaults and maximum size of the header table.
@@ -113,37 +98,50 @@ module HTTP2
         @type = type
         @table = (type == :request) ? REQ_DEFAULTS.dup : RESP_DEFAULTS.dup
         @limit = limit
-        @workset = []
+        @refset = []
       end
 
       # Performs differential coding based on provided command type.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-01#section-3.1
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-3.2
       #
       # @param cmd [Hash]
+      # @return [Hash] emitted header
       def process(cmd)
+        emit = nil
+
         # indexed representation
         if cmd[:type] == :indexed
-          # For an indexed representation, the decoder checks whether the index
-          # is present in the working set. If true, the corresponding entry is
-          # removed from the working set. If several entries correspond to this
-          # encoded index, all these entries are removed from the working set.
-          # If the index is not present in the working set, it is used to
-          # retrieve the corresponding header from the header table, and a new
-          # entry is added to the working set representing this header.
-          cur = @workset.find_index {|(i,v)| i == cmd[:name]}
+          # An indexed representation corresponding to an entry not present
+          # in the reference set entails the following actions:
+          # - The header corresponding to the entry is emitted.
+          # - The entry is added to the reference set.
+          #
+          # An indexed representation corresponding to an entry present in
+          # the reference set entails the following actions:
+          #  - The entry is removed from the reference set.
+          #
+          idx = cmd[:name]
+          cur = @refset.find_index {|(i,v)| i == idx}
 
           if cur
-            @workset.delete_at(cur)
+            @refset.delete_at(cur)
           else
-            @workset.push [cmd[:name], @table[cmd[:name]]]
+            emit = @table[idx]
+            @refset.push [idx, @table[idx]]
           end
 
         else
-          # For a literal representation, a new entry is added to the working
-          # set representing this header. If the literal representation specifies
-          # that the header is to be indexed, the header is added accordingly to
-          # the header table, and its index is included in the entry in the working
-          # set. Otherwise, the entry in the working set contains an undefined index.
+          # A literal representation that is not added to the header table
+          # entails the following action:
+          #  - The header is emitted.
+          #
+          # A literal representation that is added to the header table entails
+          # the following actions:
+          #  - The header is emitted.
+          #  - The header is added to the header table, at the location
+          #    defined by the representation.
+          #  - The new entry is added to the reference set.
+          #
           if cmd[:name].is_a? Integer
             k,v = @table[cmd[:name]]
 
@@ -152,42 +150,29 @@ module HTTP2
             cmd[:name] = k
           end
 
-          newval = [cmd[:name], cmd[:value]]
+          emit = [cmd[:name], cmd[:value]]
 
           if cmd[:type] != :noindex
-            size_check cmd
-
-            case cmd[:type]
-            when :incremental
-              cmd[:index] = @table.size
-            when :substitution
-              if @table[cmd[:index]].nil?
-                raise HeaderException.new("invalid index")
+            if size_check(cmd)
+
+              case cmd[:type]
+              when :incremental
+                cmd[:index] = @table.size
+              when :substitution
+                if @table[cmd[:index]].nil?
+                  raise HeaderException.new("invalid index")
+                end
+              when :prepend
+                @table = [emit] + @table
               end
-            when :prepend
-              @table = [newval] + @table
-            end
 
-            @table[cmd[:index]] = newval
+              @table[cmd[:index]] = emit
+              @refset.push [cmd[:index], emit]
+            end
           end
-
-          @workset.push [cmd[:index], newval]
         end
-      end
 
-      # First, upon starting the decoding of a new set of headers, the
-      # reference set of headers is interpreted into the working set of
-      # headers: for each header in the reference set, an entry is added to
-      # the working set, containing the header name, its value, and its
-      # current index in the header table.
-      #
-      # @return [Array] current working set
-      def update_sets
-        # new refset is the the workset sans headers not in header table
-        refset = @workset.reject {|(i,h)| !@table.include? h}
-
-        # new workset is the refset with index of each header in header table
-        @workset = refset.collect {|(i,h)| [@table.find_index(h), h]}
+        emit
       end
 
       # Emits best available command to encode provided header.
@@ -230,40 +215,55 @@ module HTTP2
 
       private
 
-      # Before adding a new entry to the header table or changing an existing
-      # one, a check has to be performed to ensure that the change will not
-      # cause the table to grow in size beyond the SETTINGS_MAX_BUFFER_SIZE
-      # limit. If necessary, one or more items from the beginning of the
-      # table are removed until there is enough free space available to make
-      # the modification.  Dropping an entry from the beginning of the table
-      # causes the index positions of the remaining entries in the table to
-      # be decremented by 1.
+      # Before doing such a modification, it has to be ensured that the header
+      # table size will stay lower than or equal to the
+      # SETTINGS_HEADER_TABLE_SIZE limit. To achieve this, repeatedly, the
+      # first entry of the header table is removed, until enough space is
+      # available for the modification.
+      #
+      # A consequence of removing one or more entries at the beginning of the
+      # header table is that the remaining entries are renumbered.  The first
+      # entry of the header table is always associated to the index 0.
       #
       # @param cmd [Hash]
+      # @return [Boolean]
       def size_check(cmd)
         cursize = @table.join.bytesize + @table.size * 32
         cmdsize = cmd[:name].bytesize + cmd[:value].bytesize + 32
 
+        # The addition of a new entry with a size greater than the
+        # SETTINGS_HEADER_TABLE_SIZE limit causes all the entries from the
+        # header table to be dropped and the new entry not to be added to the
+        # header table.  The replacement of an existing entry with a new entry
+        # with a size greater than the SETTINGS_HEADER_TABLE_SIZE has the same
+        # consequences.
+        if cmdsize > @limit
+          @table.clear
+          return false
+        end
+
         cur = 0
         while (cursize + cmdsize) > @limit do
           e = @table.shift
 
-          # When using substitution indexing, it is possible that the existing
-          # item being replaced might be one of the items removed when performing
-          # the necessary size adjustment.  In such cases, the substituted value
-          # being added to the header table is inserted at the beginning of the
-          # header table (at index position #0) and the index positions of the
-          # other remaining entries in the table are incremented by 1.
+          # When the modification of the header table is the replacement of an
+          # existing entry, the replaced entry is the one indicated in the
+          # literal representation before any entry is removed from the header
+          # table. If the entry to be replaced is removed from the header table
+          # when performing the size adjustment, the replacement entry is
+          # inserted at the beginning of the header table.
           if cmd[:type] == :substitution && cur == cmd[:index]
              cmd[:type] = :prepend
            end
 
           cursize -= (e.join.bytesize + 32)
         end
+
+        return true
       end
 
       def active?(idx)
-        !@workset.find {|i,_| i == idx }.nil?
+        !@refset.find {|i,_| i == idx }.nil?
       end
 
       def default?(idx)
@@ -289,20 +289,20 @@ module HTTP2
     #   server_role = Compressor.new(:response)
     class Compressor
       def initialize(type)
-        @cc = CompressionContext.new(type)
+        @cc = EncodingContext.new(type)
       end
 
       # Encodes provided value via integer representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-01#section-4.2.1
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4.1.1
       #
-      #   If I < 2^N - 1, encode I on N bits
-      #   Else, encode 2^N - 1 on N bits and do the following steps:
-      #    Set I to (I - (2^N - 1)) and Q to 1
-      #    While Q > 0
-      #      Compute Q and R, quotient and remainder of I divided by 2^7
-      #      If Q is strictly greater than 0, write one 1 bit; otherwise, write one 0 bit
-      #      Encode R on the next 7 bits
-      #      I = Q
+      #  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
@@ -315,21 +315,17 @@ module HTTP2
         bytes.push limit if !n.zero?
 
         i -= limit
-        q = 1
-
-        while (q > 0) do
-          q, r = i.divmod(128)
-          r += 128 if (q > 0)
-          i = q
-
-          bytes.push(r)
+        while (i >= 128) do
+          bytes.push((i % 128) + 128)
+          i = 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-01#section-4.2.2
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4.1.3
       #
       # * The string length, defined as the number of bytes needed to store
       #   its UTF-8 representation, is represented as an integer with a zero
@@ -340,15 +336,15 @@ module HTTP2
       # @param str [String]
       # @return [String] binary string
       def string(str)
-        integer(str.bytesize, 0) + str.dup.force_encoding('binary')
+        integer(str.bytesize, 0) << str.dup.force_encoding('binary')
       end
 
       # Encodes header command with appropriate header representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-01#section-4.3
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4
       #
       # @param h [Hash] header command
       # @param buffer [String]
-      def header(h, buffer = "")
+      def header(h, buffer = Buffer.new)
         rep = HEADREP[h[:type]]
 
         if h[:type] == :indexed
@@ -383,29 +379,35 @@ module HTTP2
       # Encodes provided list of HTTP headers.
       #
       # @param headers [Hash]
-      # @return [String] binary string
+      # @return [Buffer]
       def encode(headers)
+        buffer = Buffer.new
         commands = []
-        @cc.update_sets
 
-        # Remove missing headers from the working set
-        @cc.workset.each do |idx, (wk,wv)|
+        # Literal header names MUST be translated to lowercase before
+        # encoding and transmission.
+        headers.map! {|(hk,hv)| [hk.downcase, hv] }
+
+        # Generate remove commands for missing headers
+        @cc.refset.each do |idx, (wk,wv)|
           if headers.find {|(hk,hv)| hk == wk && hv == wv }.nil?
             commands.push @cc.removecmd idx
           end
         end
 
-        # Add missing headers to the working set
+        # Generate add commands for new headers
         headers.each do |(hk,hv)|
-          if @cc.workset.find {|i,(wk,wv)| hk == wk && hv == wv}.nil?
+          if @cc.refset.find {|i,(wk,wv)| hk == wk && hv == wv}.nil?
             commands.push @cc.addcmd [hk, hv]
           end
         end
 
-        commands.map do |cmd|
+        commands.each do |cmd|
           @cc.process cmd.dup
-          header cmd
-        end.join
+          buffer << header(cmd)
+        end
+
+        buffer
       end
     end
 
@@ -418,7 +420,7 @@ module HTTP2
     #   client_role = Decompressor.new(:response)
     class Decompressor
       def initialize(type)
-        @cc = CompressionContext.new(type)
+        @cc = EncodingContext.new(type)
       end
 
       # Decodes integer value from provided buffer.
@@ -430,7 +432,7 @@ module HTTP2
         i = !n.zero? ? (buf.getbyte & limit) : 0
 
         m = 0
-        buf.each_byte do |byte|
+        while byte = buf.getbyte do
           i += ((byte & 127) << m)
           m += 7
 
@@ -450,10 +452,9 @@ module HTTP2
 
       # Decodes header command from provided buffer.
       #
-      # @param buf [String]
+      # @param buf [Buffer]
       def header(buf)
-        peek = buf.getbyte
-        buf.seek(-1, IO::SEEK_CUR)
+        peek = buf.readbyte(0)
 
         header = {}
         header[:type], type = HEADREP.select do |t, desc|
@@ -481,11 +482,26 @@ module HTTP2
 
       # Decodes and processes header commands within provided buffer.
       #
-      # @param buf [String]
+      # Once all the representations contained in a header block have been
+      # processed, the headers that are in common with the previous header
+      # set are emitted, during the reference set emission.
+      #
+      # For the reference set emission, each header contained in the
+      # reference set that has not been emitted during the processing of the
+      # header block is emitted.
+      #
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-3.2.2
+      #
+      # @param buf [Buffer]
+      # @return [Array] set of HTTP headers
       def decode(buf)
-        @cc.update_sets
-        @cc.process(header(buf)) while !buf.eof?
-        @cc.workset.map {|i,header| header}
+        set = []
+        set << @cc.process(header(buf)) while !buf.empty?
+        @cc.refset.each do |i,header|
+          set << header if !set.include? header
+        end
+
+        set.compact
       end
     end