http-hpack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29b1f18fa2d9df85696ed6947a352cd458b9621b24a07f0bdb60b545f89b170f
+  data.tar.gz: 89bc9927bbe44b282132d284e07bd7d130f324d4706340e3ec4f6c559cc6c55d
+SHA512:
+  metadata.gz: ecf69ccff7790a4ddf0c4ae6064898e969ce841df18629ab3e1aa6d15266a664196c9b2a7464e3d9b4492b54ec525b2414e89abd5f1127dfb606cf624c162179
+  data.tar.gz: a6a13dc0c7534812e363d433a3fa3e54d9121c3276a7eb90d8044ee58b0c471c814e40903ac2040235dd8475ab32252f8853cbd6cbd977b4d950ea0aee24fbe1

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "spec/http/hpack/hpack-test-case"]
+	path = spec/http/hpack/hpack-test-case
+	url = https://github.com/http2jp/hpack-test-case.git

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--warnings
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+sudo: required
+dist: xenial
+cache: bundler
+
+before_script:
+  - gem update --system
+  - gem install bundler
+
+matrix:
+  include:
+    - rvm: 2.3
+    - rvm: 2.4
+    - rvm: 2.5
+    - rvm: 2.6
+    - rvm: jruby-head
+      env: JRUBY_OPTS="--debug -X+O"
+    - rvm: ruby-head
+    - rvm: rbx-3
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx-3

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in http-hpack.gemspec
+gemspec
+
+group :test do
+	gem 'covered', require: 'covered/rspec' if RUBY_VERSION >= "2.6.0"
+end

data/README.md

@@ -0,0 +1,75 @@
+# HTTP::HPACK
+
+Provides a compressor and decompressor for HTTP 2.0 headers, HPACK, as defined by [RFC7541](https://tools.ietf.org/html/rfc7541).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'http-hpack'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install http-hpack
+
+## Usage
+
+### Compressing Headers
+
+```ruby
+buffer = String.new.b
+compressor = HTTP::HPACK::Compressor.new(buffer)
+
+compressor.encode([['content-length', '5']])
+=> "\\\x015"
+```
+
+### Decompressing Headers
+
+Reusing `buffer` from above:
+
+```ruby
+decompressor = HTTP::HPACK::Decompressor.new(buffer)
+
+decompressor.decode
+=> [["content-length", "5"]]
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Released under the MIT license.
+
+Copyright, 2018, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).  
+Copyrigh, 2013, by Ilya Grigorik.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+load *Dir["tasks/*.rake"]

data/http-hpack.gemspec

@@ -0,0 +1,22 @@
+
+require_relative "lib/http/hpack/version"
+
+Gem::Specification.new do |spec|
+	spec.name          = "http-hpack"
+	spec.version       = HTTP::HPACK::VERSION
+	spec.authors       = ["Samuel Williams"]
+	spec.email         = ["samuel.williams@oriontransfer.co.nz"]
+
+	spec.summary       = "A compresssor and decompressor for HTTP 2.0 HPACK."
+	spec.homepage      = "https://github.com/socketry/http-hpack"
+
+	spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+		f.match(%r{^(test|spec|features)/})
+	end
+	
+	spec.require_paths = ["lib"]
+
+	spec.add_development_dependency "bundler", "~> 1.16"
+	spec.add_development_dependency "rake", "~> 10.0"
+	spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/http/hpack.rb

@@ -0,0 +1,21 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require "http/hpack/version"

data/lib/http/hpack/compressor.rb

@@ -0,0 +1,193 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyrigh, 2013, by Ilya Grigorik.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'context'
+require_relative 'huffman'
+
+module HTTP
+	module HPACK
+		# Predefined options set for Compressor
+		# http://mew.org/~kazu/material/2014-hpack.pdf
+		NAIVE = {index: :never, huffman: :never}
+		LINEAR = {index: :all, huffman: :never}
+		STATIC = {index: :static, huffman: :never}
+		SHORTER = {index: :all, huffman: :never}
+		NAIVE_HUFFMAN = {index: :never, huffman: :always}
+		LINEAR_HUFFMAN = {index: :all, huffman: :always}
+		STATIC_HUFFMAN = {index: :static, huffman: :always}
+		SHORTER_HUFFMAN = {index: :all, huffman: :shorter}
+		
+		MODES = {
+			naive: NAIVE,
+			linear: LINEAR,
+			static: STATIC,
+			shorter: SHORTER,
+			naive_huffman: NAIVE_HUFFMAN,
+			linear_huffman: NAIVE_HUFFMAN,
+			static_huffman: NAIVE_HUFFMAN,
+			shorter_huffman: NAIVE_HUFFMAN,
+		}
+		
+		# Responsible for encoding header key-value pairs using HPACK algorithm.
+		class Compressor
+			def initialize(buffer, context = Context.new)
+				@buffer = buffer
+				@context = context
+			end
+
+			attr :buffer
+			attr :context
+			attr :offset
+
+			def write_byte(byte)
+				@buffer << byte.chr
+			end
+			
+			def write_bytes(bytes)
+				@buffer << bytes
+			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 value [Integer] value to encode
+			# @param bits [Integer] number of available bits
+			# @return [String] binary string
+			def write_integer(value, bits)
+				limit = 2**bits - 1
+				
+				return write_bytes([value].pack('C')) if value < limit
+				
+				bytes = []
+				bytes.push(limit) unless bits.zero?
+				
+				value -= limit
+				while value >= 128
+					bytes.push((value % 128) + 128)
+					value /= 128
+				end
+				
+				bytes.push(value)
+				
+				write_bytes(bytes.pack('C*'))
+			end
+			
+			def huffman
+				@context.options[:huffman]
+			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 string [String]
+			# @return [String] binary string
+			def write_string(string, huffman = self.huffman)
+				if huffman != :never
+					encoded = Huffman.new.encode(string)
+					
+					if huffman == :shorter and encoded.bytesize >= string.bytesize
+						encoded = nil
+					end
+				end
+				
+				if encoded
+					first = @buffer.bytesize
+					
+					write_integer(encoded.bytesize, 7)
+					write_bytes(encoded.b)
+					
+					@buffer.setbyte(first, @buffer.getbyte(first).ord | 0x80)
+				else
+					write_integer(string.bytesize, 7)
+					write_bytes(string.b)
+				end
+			end
+
+			# Encodes header command with appropriate header representation.
+			#
+			# @param h [Hash] header command
+			# @param buffer [String]
+			# @return [Buffer]
+			def write_header(command)
+				representation = HEADER_REPRESENTATION[command[:type]]
+				
+				first = @buffer.bytesize
+				
+				case command[:type]
+				when :indexed
+					write_integer(command[:name] + 1, representation[:prefix])
+				when :changetablesize
+					write_integer(command[:value], representation[:prefix])
+				else
+					if command[:name].is_a? Integer
+						write_integer(command[:name] + 1, representation[:prefix])
+					else
+						write_integer(0, representation[:prefix])
+						write_string(command[:name])
+					end
+					
+					write_string(command[:value])
+				end
+
+				# set header representation pattern on first byte
+				@buffer.setbyte(first, @buffer.getbyte(first) | representation[:pattern])
+			end
+
+			# Encodes provided list of HTTP headers.
+			#
+			# @param headers [Array] +[[name, value], ...]+
+			# @return [Buffer]
+			def encode(headers)
+				commands = @context.encode(headers)
+				
+				commands.each do |command|
+					write_header(command)
+				end
+				
+				return @buffer
+			end
+		end
+	end
+end

data/lib/http/hpack/context.rb

@@ -0,0 +1,337 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyrigh, 2013, by Ilya Grigorik.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'huffman'
+
+module HTTP
+	# 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
+	module HPACK
+		# Header representation as defined by the spec.
+		HEADER_REPRESENTATION = {
+			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},
+		}
+		
+		# To decompress header blocks, a decoder only needs to maintain a
+		# dynamic table as a decoding context.
+		# No other state information is needed.
+		class Context
+			# @private
+			# Static table
+			# - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#appendix-A
+			STATIC_TABLE = [
+				[':authority',                  ''],
+				[':method',                     'GET'],
+				[':method',                     'POST'],
+				[':path',                       '/'],
+				[':path',                       '/index.html'],
+				[':scheme',                     'http'],
+				[':scheme',                     'https'],
+				[':status',                     '200'],
+				[':status',                     '204'],
+				[':status',                     '206'],
+				[':status',                     '304'],
+				[':status',                     '400'],
+				[':status',                     '404'],
+				[':status',                     '500'],
+				['accept-charset',              ''],
+				['accept-encoding',             'gzip, deflate'],
+				['accept-language',             ''],
+				['accept-ranges',               ''],
+				['accept',                      ''],
+				['access-control-allow-origin', ''],
+				['age',                         ''],
+				['allow',                       ''],
+				['authorization',               ''],
+				['cache-control',               ''],
+				['content-disposition',         ''],
+				['content-encoding',            ''],
+				['content-language',            ''],
+				['content-length',              ''],
+				['content-location',            ''],
+				['content-range',               ''],
+				['content-type',                ''],
+				['cookie',                      ''],
+				['date',                        ''],
+				['etag',                        ''],
+				['expect',                      ''],
+				['expires',                     ''],
+				['from',                        ''],
+				['host',                        ''],
+				['if-match',                    ''],
+				['if-modified-since',           ''],
+				['if-none-match',               ''],
+				['if-range',                    ''],
+				['if-unmodified-since',         ''],
+				['last-modified',               ''],
+				['link',                        ''],
+				['location',                    ''],
+				['max-forwards',                ''],
+				['proxy-authenticate',          ''],
+				['proxy-authorization',         ''],
+				['range',                       ''],
+				['referer',                     ''],
+				['refresh',                     ''],
+				['retry-after',                 ''],
+				['server',                      ''],
+				['set-cookie',                  ''],
+				['strict-transport-security',   ''],
+				['transfer-encoding',           ''],
+				['user-agent',                  ''],
+				['vary',                        ''],
+				['via',                         ''],
+				['www-authenticate',            ''],
+		 ].each {|pair| pair.each(&:freeze).freeze}.freeze
+
+			# Current table of header key-value pairs.
+			attr_reader :table
+
+			# Current encoding options
+			#
+			#   :table_size  Integer  maximum dynamic table size in bytes
+			#   :huffman     Symbol   :always, :never, :shorter
+			#   :index       Symbol   :all, :static, :never
+			attr_reader :options
+
+			# Initializes compression context with appropriate client/server
+			# defaults and maximum size of the dynamic table.
+			#
+			# @param options [Hash] encoding options
+			#   :table_size  Integer  maximum dynamic table size in bytes
+			#   :huffman     Symbol   :always, :never, :shorter
+			#   :index       Symbol   :all, :static, :never
+			def initialize(**options)
+				default_options = {
+					huffman: :shorter,
+					index: :all,
+					table_size: 4096,
+				}
+				
+				@table = []
+				@options = default_options.merge(options)
+				@limit = @options[:table_size]
+			end
+
+			# Duplicates current compression context
+			# @return [Context]
+			def dup
+				other = Context.new(@options)
+				
+				other.instance_variable_set :@table, @table.dup
+				other.instance_variable_set :@limit, @limit
+				
+				return other
+			end
+
+			# Finds an entry in current dynamic table by index.
+			# Note that index is zero-based in this module.
+			#
+			# If the index is greater than the last index in the static table,
+			# an entry in the dynamic table is dereferenced.
+			#
+			# If the index is greater than the last header index, an error is raised.
+			#
+			# @param index [Integer] zero-based index in the dynamic table.
+			# @return [Array] +[key, value]+
+			def dereference(index)
+				# NOTE: index is zero-based in this module.
+				value = STATIC_TABLE[index] || @table[index - STATIC_TABLE.size]
+				
+				raise CompressionError, "Index #{index} too large" unless value
+				
+				return value
+			end
+
+			# Header Block Processing
+			# - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-4.1
+			#
+			# @param command [Hash] {type:, name:, value:, index:}
+			# @return [Array] +[name, value]+ header field that is added to the decoded header list
+			def decode(command)
+				emit = nil
+
+				case command[:type]
+				when :changetablesize
+					self.table_size = command[:value]
+
+				when :indexed
+					# Indexed Representation
+					# An _indexed representation_ entails the following actions:
+					# o  The header field corresponding to the referenced entry in either
+					# the static table or dynamic table is added to the decoded header
+					# list.
+					idx = command[:name]
+
+					k, v = dereference(idx)
+					emit = [k, v]
+
+				when :incremental, :noindex, :neverindexed
+					# A _literal representation_ that is _not added_ to the dynamic table
+					# entails the following action:
+					# o  The header field is added to the decoded header list.
+
+					# A _literal representation_ that is _added_ to the dynamic table
+					# entails the following actions:
+					# 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 command[:name].is_a? Integer
+						k, v = dereference(command[:name])
+
+						command = command.dup
+						command[:index] ||= command[:name]
+						command[:value] ||= v
+						command[:name] = k
+					end
+
+					emit = [command[:name], command[:value]]
+
+					add_to_table(emit) if command[:type] == :incremental
+
+				else
+					raise CompressionError, "Invalid type: #{command[:type]}"
+				end
+
+				return emit
+			end
+
+			# Plan header compression according to +@options [:index]+
+			#  :never   Do not use dynamic table or static table reference at all.
+			#  :static  Use static table only.
+			#  :all     Use all of them.
+			#
+			# @param headers [Array] +[[name, value], ...]+
+			# @return [Array] array of commands
+			def encode(headers)
+				commands = []
+				
+				# Literals commands are marked with :noindex when index is not used
+				noindex = [:static, :never].include?(@options[:index])
+				
+				headers.each do |field, value|
+					command = add_command(field, value)
+					command[:type] = :noindex if noindex && command[:type] == :incremental
+					commands << command
+					
+					decode(command)
+				end
+				
+				return commands
+			end
+
+			# Emits command for a header.
+			# Prefer static table over dynamic table.
+			# Prefer exact match over name-only match.
+			#
+			# +@options [:index]+ controls whether to use the dynamic table,
+			# static table, or both.
+			#  :never   Do not use dynamic table or static table reference at all.
+			#  :static  Use static table only.
+			#  :all     Use all of them.
+			#
+			# @param header [Array] +[name, value]+
+			# @return [Hash] command
+			def add_command(*header)
+				exact = nil
+				name_only = nil
+
+				if [:all, :static].include?(@options[:index])
+					STATIC_TABLE.each_index do |i|
+						if STATIC_TABLE[i] == header
+							exact ||= i
+							break
+						elsif STATIC_TABLE[i].first == header.first
+							name_only ||= i
+						end
+					end
+				end
+				if [:all].include?(@options[:index]) && !exact
+					@table.each_index do |i|
+						if @table[i] == header
+							exact ||= i + STATIC_TABLE.size
+							break
+						elsif @table[i].first == header.first
+							name_only ||= i + STATIC_TABLE.size
+						end
+					end
+				end
+
+				if exact
+					{name: exact, type: :indexed}
+				elsif name_only
+					{name: name_only, value: header.last, type: :incremental}
+				else
+					{name: header.first, value: header.last, type: :incremental}
+				end
+			end
+
+			# Alter dynamic table size.
+			#  When the size is reduced, some headers might be evicted.
+			def table_size=(size)
+				@limit = size
+				size_check(nil)
+			end
+
+			# Returns current table size in octets
+			# @return [Integer]
+			def current_table_size
+				@table.inject(0) {|r, (k, v)| r + k.bytesize + v.bytesize + 32}
+			end
+
+			private
+
+			# Add a name-value pair to the dynamic table.
+			# Older entries might have been evicted so that
+			# the new entry fits in the dynamic table.
+			#
+			# @param command [Array] +[name, value]+
+			def add_to_table(command)
+				return unless size_check(command)
+				@table.unshift(command)
+			end
+
+			# To keep the dynamic table size lower than or equal to @limit,
+			# remove one or more entries at the end of the dynamic table.
+			#
+			# @param command [Hash]
+			# @return [Boolean] whether +command+ fits in the dynamic table.
+			def size_check(command)
+				cursize = current_table_size
+				cmdsize = command.nil? ? 0 : command[0].bytesize + command[1].bytesize + 32
+
+				while cursize + cmdsize > @limit
+					break if @table.empty?
+
+					e = @table.pop
+					cursize -= e[0].bytesize + e[1].bytesize + 32
+				end
+
+				cmdsize <= @limit
+			end
+		end
+	end
+end