http-2 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: debc6f11031e879547dd45605849500e45fd1142
-  data.tar.gz: 61e60a0b2b831553a9ecca42b069c032afe12e30
+  metadata.gz: c7bbedd001cf6de0ec84caef4ccd0e4e818315d3
+  data.tar.gz: c1129e49ae319b1cf31151f4e75bf16f0a108e0a
 SHA512:
-  metadata.gz: b7c36dec0419a45e75f8664e6ac4ede157c49057d51bd7f25f795139313048978e4c053e49d90f0140731ec36b2a7df68fd075c50bb1f9cf98169b3192571ddd
-  data.tar.gz: 9ab31eb78ec61a37139efeba7185a87cd742588f30a456b35bbeb8935e50487cd948be09e9fed68ba1510ef91db88916815cc30ab41941634b567be59b56099c
+  metadata.gz: 6c68277cdbc49a1fd695c177e1015334946e4cbba9e93cc2b7b93572b45ab89c61e92ed2638f485c1eafaa2909f1d8a8d0c3ae352743697176b37bf1b27e8be3
+  data.tar.gz: 3357aafb0da7559f22230e8503bd025b4c993ce0fc1dbcc40d078b6b6d0bb5b98b831f40b0d9f53c0358b42939dc7697b72b319ce183975eaaea6e95c092b96a

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitmodules

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

data/Gemfile

@@ -6,6 +6,11 @@ gem 'yard'
 group :test do
   gem 'coveralls', :require => false
   gem 'rspec'
+  gem 'rspec-autotest'
+  gem 'autotest-standalone'
+  gem 'autotest-growl'
+  gem 'pry'
+  gem 'pry-byebug'
 end
 
 gemspec

data/README.md

@@ -3,6 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/http-2.png)](http://rubygems.org/gems/http-2)
 [![Build Status](https://travis-ci.org/igrigorik/http-2.png?branch=master)](https://travis-ci.org/igrigorik/http-2)
 [![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.png)](https://coveralls.io/r/igrigorik/http-2)
+[![Analytics](https://ga-beacon.appspot.com/UA-71196-10/http-2/readme)](https://github.com/igrigorik/ga-beacon)
 
 Pure ruby, framework and transport agnostic implementation of [HTTP 2.0 protocol](http://tools.ietf.org/html/draft-ietf-httpbis-http2) with support for:
 
@@ -15,8 +16,8 @@ Pure ruby, framework and transport agnostic implementation of [HTTP 2.0 protocol
 
 Current implementation (see [HPBN chapter for HTTP 2.0 overview](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html)), is based on:
 
-* [draft-ietf-httpbis-http2-06](http://tools.ietf.org/html/draft-ietf-httpbis-http2-06)
-* [draft-ietf-httpbis-header-compression-03](http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03)
+* [draft-ietf-httpbis-http2-14](http://tools.ietf.org/html/draft-ietf-httpbis-http2-14)
+* [draft-ietf-httpbis-header-compression-09](http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09)
 
 _Note: the underlying specifications are still evolving, expect APIs to change and evolve also..._
 
@@ -43,7 +44,7 @@ while bytes = socket.read
 end
 ```
 
-Checkout provided [client](https://github.com/igrigorik/http-2/blob/master/example/client.rb) and [server]((https://github.com/igrigorik/http-2/blob/master/example/server.rb) implementations for basic examples.
+Checkout provided [client](https://github.com/igrigorik/http-2/blob/master/example/client.rb) and [server](https://github.com/igrigorik/http-2/blob/master/example/server.rb) implementations for basic examples.
 
 
 ### Connection lifecycle management
@@ -283,4 +284,4 @@ client.settings(streams: 0) # setting max limit to 0 disables server push
 
 ### License
 
-(MIT License) - Copyright (c) 2013 Ilya Grigorik
+(MIT License) - Copyright (c) 2013 Ilya Grigorik ![GA](https://www.google-analytics.com/__utm.gif?utmac=UA-71196-9&utmhn=github.com&utmdt=HTTP2&utmp=/http-2/readme)

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require_relative "lib/tasks/generate_huffman_table"
 
 desc "Run all RSpec tests"
 RSpec::Core::RakeTask.new(:spec)

data/example/client.rb

@@ -39,10 +39,16 @@ end
 
 conn = HTTP2::Client.new
 conn.on(:frame) do |bytes|
-  puts "Sending bytes: #{bytes.inspect}"
+  # puts "Sending bytes: #{bytes.unpack("H*").first}"
   sock.print bytes
   sock.flush
 end
+conn.on(:frame_sent) do |frame|
+  puts "Sent frame: #{frame.inspect}"
+end
+conn.on(:frame_received) do |frame|
+  puts "Received frame: #{frame.inspect}"
+end
 
 stream = conn.new_stream
 log = Logger.new(stream.id)
@@ -57,6 +63,10 @@ conn.on(:promise) do |promise|
   end
 end
 
+conn.on(:altsvc) do |f|
+  log.info "received ALTSVC #{f}"
+end
+
 stream.on(:close) do
   log.info "stream closed"
   sock.close
@@ -75,16 +85,21 @@ stream.on(:data) do |d|
   log.info "response data chunk: <<#{d}>>"
 end
 
+stream.on(:altsvc) do |f|
+  log.info "received ALTSVC #{f}"
+end
+
+
 head = {
   ":scheme" => uri.scheme,
-  ":method" => (options[:payload].nil? ? "get" : "post"),
-  ":host" => [uri.host, uri.port].join(':'),
+  ":method" => (options[:payload].nil? ? "GET" : "POST"),
+  ":authority" => [uri.host, uri.port].join(':'),
   ":path" => uri.path,
   "accept" => "*/*"
 }
 
 puts "Sending HTTP 2.0 request"
-if head[":method"] == "get"
+if head[":method"] == "GET"
   stream.headers(head, end_stream: true)
 else
   stream.headers(head, end_stream: false)
@@ -93,7 +108,7 @@ end
 
 while !sock.closed? && !sock.eof?
   data = sock.read_nonblock(1024)
-  # puts "Received bytes: #{data.inspect}"
+  # puts "Received bytes: #{data.unpack("H*").first}"
 
   begin
     conn << data

data/example/helper.rb

@@ -6,7 +6,7 @@ require 'openssl'
 require 'http/2'
 require 'uri'
 
-DRAFT = 'HTTP-draft-06/2.0'
+DRAFT = 'h2-14'
 
 class Logger
   def initialize(id)

data/example/keys/mycert.pem

@@ -1,24 +1,23 @@
 -----BEGIN CERTIFICATE-----
-MIID9DCCAtygAwIBAgIJAKIwkCCNJr2mMA0GCSqGSIb3DQEBBQUAMFkxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMjA2MjQxODE4
-MTZaFw0xMzA2MjQxODE4MTZaMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21l
-LVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNV
-BAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOTQ
-eHgUpZnggH2RwBeghuf86/7wNeO4DIJacLrmCynA871ioOvxzPx5jPTV6dkkitMT
-lNroneNa/BbRHHOVUvCtuJyKXEiFyWs/jCYAZ335uMYtDK2FAHRvNgXMM1YZTpbM
-CSIteVsWIAuNFAWwQS8Bd9oACUS1P69eNbA1BBOqnaYoZT1D+JD4bp9kpBYqXJtf
-wOgHGzPOVatqzJDgOqSwYVz1ZETVopv+TMBght938iVoow2cHnJ2Zj/n/jBkG8E9
-FNlmc67WqQkJsS16E9sEntJOSNldBRsjMFux4E+g7wzyn9tFJ0nYJ/rklWa24BN7
-Vg9diYljQNLLSMv8/tcCAwEAAaOBvjCBuzAdBgNVHQ4EFgQUqBtvGKKXRaXzFV16
-W1uMzroa8SkwgYsGA1UdIwSBgzCBgIAUqBtvGKKXRaXzFV16W1uMzroa8SmhXaRb
-MFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJ
-bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdIIJAKIw
-kCCNJr2mMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBALji7DAGBRU9
-x6/zw7EcEDlutGv6qp1VasJzSexVCZAr5c7vSDbdM+wlAxvwBguoFNLvrIvBxUMN
-pf/lvig2Q++lGTiqu5VodnmJXnqze7PO2Rdq9Yqgkva7qVFuGrYwGTXfiuz5LqGV
-BWz/i1i8EwJmO+p0yLk+r1hjBaeAqfbZtt1ACeZgu/8zaI9ypb2vpwOyW5TUJ8hk
-S+ZAX1Pd5OMqerD6DTfD/McHkWnC3ilcW4ZQIIJABKGxPc7k9Gyod9PZIPJS/ER7
-7koJ84u8esvnaP3DGHIuWngMpQcgMzJbD5bNX+C0DoaxkWre8u7afCW68a58RP19
-LTlr/GlI51c=
+MIID1zCCAr+gAwIBAgIJANjbVITTVqaAMA0GCSqGSIb3DQEBBQUAMFAxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMRgwFgYDVQQKEw9TUERZIFByb3h5
+IERlbW8xEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xNDEwMTQwNDUwMTJaFw0xNTEw
+MTQwNDUwMTJaMFAxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMRgw
+FgYDVQQKEw9TUERZIFByb3h5IERlbW8xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMxv7mqzNMVVFoBjqOSUy2cNM9c6
+6gTgVLr9ssoLU0TC4biY1B/KoD7G9Ive6PwfdpipgGY+tuPHfEzBCCHD7exER1NL
+npWauo6Lwh3wOjuo5Er6klgBGFuHYx8jJ2jBwCFvTcG2zJRedU/Pby6Fa27X6acw
+faAtReG5YOHs8YRmg4ErWqfRucoM3zj8vvMWnushMhYQxo1EVLJ2EvvbHEkip4ap
+pro+2Ql0KY4XT3EoMTRHICbolK/uQYoe0musKnwCGPg2NL6e27uvi47G7GrIpcf3
+HN4HZMoOzJ8ti7IIEkF0fVTgQEVkluInfned69WCwxecMQZs5sdBuwE3Kh0CAwEA
+AaOBszCBsDAdBgNVHQ4EFgQU86bqiYciIYDN+KAPlnJL6tSbH6IwgYAGA1UdIwR5
+MHeAFPOm6omHIiGAzfigD5ZyS+rUmx+ioVSkUjBQMQswCQYDVQQGEwJBVTETMBEG
+A1UECBMKU29tZS1TdGF0ZTEYMBYGA1UEChMPU1BEWSBQcm94eSBEZW1vMRIwEAYD
+VQQDEwlsb2NhbGhvc3SCCQDY21SE01amgDAMBgNVHRMEBTADAQH/MA0GCSqGSIb3
+DQEBBQUAA4IBAQCkcr0DLPCbP5l9G0YI/XKVsUW9fXcTvge6Eko0R8qAkzTcsZQv
+DbKcIM3z52QguCuJ9k63X4p174FKq7+qmieqaifosGKV03pyyxWLMpRooUUVXEBM
+gZaRfp9VG2N4zrRaIklOSkAscnwybv2U3LZhKDlc7Yatsr1/TFkbCnzll514UnTz
+ewjrlzVitUSEkwEGvLhKQuVPM9/3MAm+ztFpx846/GZ2XJSAFQLtHudjMXnFLihA
+7nGZvE4rudyT70YsKu0BP0KjVZXrxTh81C4kyJu9xo4YuiDCFtvwtjoty0ygbuQN
+a38i0bxFlYFmbWHooNCPUWVy59MOnW9zxaTV
 -----END CERTIFICATE-----

data/example/keys/mykey.pem

@@ -1,27 +1,27 @@
 -----BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEA5NB4eBSlmeCAfZHAF6CG5/zr/vA147gMglpwuuYLKcDzvWKg
-6/HM/HmM9NXp2SSK0xOU2uid41r8FtEcc5VS8K24nIpcSIXJaz+MJgBnffm4xi0M
-rYUAdG82BcwzVhlOlswJIi15WxYgC40UBbBBLwF32gAJRLU/r141sDUEE6qdpihl
-PUP4kPhun2SkFipcm1/A6AcbM85Vq2rMkOA6pLBhXPVkRNWim/5MwGCG33fyJWij
-DZwecnZmP+f+MGQbwT0U2WZzrtapCQmxLXoT2wSe0k5I2V0FGyMwW7HgT6DvDPKf
-20UnSdgn+uSVZrbgE3tWD12JiWNA0stIy/z+1wIDAQABAoIBABSU5/EtMkQoHIav
-AI9fgiMF7hhtdPt5x65GAlPdc22bDJGheIYgpuai7Fntj+5XSiF4ZnBWcjVMLtbC
-koOXD/HUPoHeNDTVy+tYuPuGF8kOGF/DF5vYFdVjV4Gn/4okFpyb18p6OqtFzzYa
-x41HcGWRBT3XuP20K/lTSRMDgc1e5N9bmoOONJqT+K1ak0Dv2Ifl5RTBWbmYymgR
-30cgDkiazCNjhRCCCBX8cctB4ULiOvqdksn5Ln05jvezd1Wog/ryr4SI+HMmAroZ
-dB+F8kODO792/ahR8DusQUVpwVbHqAXOVHmtplMZ4DlIgw+qY5pRawkvdetq/Ghy
-fHAInsECgYEA/U4uNsghZJiWnpZ999esCbHwM6orgX561Nx/WsmKGv0pjslZNDrx
-5Awd0EQo/NW59CUW5RcHnK+ayAsQ1xgN4HB97xYAj5v0xEzhQw8fg39fc/4gja+j
-F89wK3nfX1F4PpisN6eir+z2UcUJLT4rIsFa57R7TbLV6eV/nhxoauECgYEA5z+Y
-ITSdgwsS8FR+8ZL/UvdmkDW34gQUZ3QEAkJZfkCaHXq90tgIHDBm8dZBKEuDHJSN
-yJQ4VeHzBD9q7pdz/qDXAw5Jqgz01ToWWuGvCbcqvH6u1UrVvUhgr0JbyUZgrL4r
-/c5buWHS+IKwtBqWG1oo4kclfz3TIjtLXiVDmLcCgYB+/K2wav5KpzCDSqDWGjo2
-Fg18aSgsYBMGGZCDHBxvUVF/MrPUumQ/1k8v9KuzrRXvLpTevn/jbimjdeC4ZGe4
-h8yqipY3aJD5xCz96Fv9GWLqDJGXVmDl8+mg8hUofPhSMUnNEO4/UgVeku/5zXvk
-jZicJl/WYPxaqOIkistSIQKBgQCoLuhFvi6QkA1GHS32JCLuBGDjoS4Lg0wTsZz4
-x6iu2e08Y3iLT/MWDV3RpTHeTI0ezCwSJTqTu7Ey9ayfuibymafG4S1SL/og2g5I
-KrtTJZQ/YyNknPi2oV0wGeMHj9ffyq/T97FeMndtph893dguLHRvna73y88ypk06
-O3/eIQKBgH10X3RoSDr04vVLFPjJ4beRj4SQA7BVUCio5MSrqkh2aTW0nFv+DiVm
-M5nqfiH5QjO1NkKXrqUYAFVdAxcLRPXSAMHK0G61HyWDKyUEwAqWQ4sZGgFrzFUb
-tihmVFKrXyzeMLumwn6TNCGVPYGAWw4FgHq59Hr+bAMp2g80Nmyj
+MIIEowIBAAKCAQEAzG/uarM0xVUWgGOo5JTLZw0z1zrqBOBUuv2yygtTRMLhuJjU
+H8qgPsb0i97o/B92mKmAZj6248d8TMEIIcPt7ERHU0uelZq6jovCHfA6O6jkSvqS
+WAEYW4djHyMnaMHAIW9NwbbMlF51T89vLoVrbtfppzB9oC1F4blg4ezxhGaDgSta
+p9G5ygzfOPy+8xae6yEyFhDGjURUsnYS+9scSSKnhqmmuj7ZCXQpjhdPcSgxNEcg
+JuiUr+5Bih7Sa6wqfAIY+DY0vp7bu6+Ljsbsasilx/cc3gdkyg7Mny2LsggSQXR9
+VOBARWSW4id+d53r1YLDF5wxBmzmx0G7ATcqHQIDAQABAoIBACybj85AZBdaxZom
+JMgbn3ZQ7yrbdAy0Vkim6sgjSHwMeewpjL+TGvwXtWx/qx64Tsxoz9d/f7Cb6odk
+5z1W3ydajqWiLmw+Ys6PuD+IF2zFIWsq2ZvSQVpXZE17AjJddGrXOoQ2OtV09uv/
+OydPfW2mNxl//ylgN4tVQ8qIRPq6b1GWWZvjTw4K3jPrlAifobYBBR+BSk446O7F
+iGvax5lNNCDMN2y+6hlnhlTHuvc0DXQA0XBhWTNYu8BNNrvC3I31RmxdY7Frm7IA
+RUGy/l2kLHCRCTF8Q0C4ydpE5ZFgpxkWK7p3QEv/gnVAwsOSN/nThdoorWWHTbNl
+pA5l1RECgYEA/ASaS9mqWWthUkOW51L6c7IIiRPAhrbPnx1mkAtUPeehHn1+G8Qu
+upUEXslWokhmQ3UAGhrId6FVYsfftNPMNck9mv4ntW7MoZLXZqTiFSqx4pQTjoYg
+PQ4c/jrQLsmislcKTiVx6kFYFcnI1ayXXEtaby0lri8XsAR5F90OpycCgYEAz6re
+DR5EZZKx61wyEfuPWE6aACWlEqlbTa8nTMddxnZUZXtzbwRFapGfs+uHCURF0dGj
+37cl4q8JdGbbYePk9nlOC4RoSw8Zh3fB4yRSZocB4yB047ofpBmt4BigGtgZ5BLZ
+zqVREgBUI+tFPPHkMmBY4lCaUsCe11SEwyZFzxsCgYEA3nRNonBy/tVbJZtFw9Eq
+BB/9isolooQRxrjUBIgLh01Dmj9ZprbILKhHIEgGsd7IbfkD6wcDNx3w2e3mGJ7v
+3fZR69M2R9+Sv3h3rEIU0mxKct8UWDUqldo0W3CcvP/9HgDYttw0rnuZfjoMjhf3
+z18wZ3xpi1RES3nXTeox+fcCgYBlPxkjrC4Ml4jHBxwiSFOK6keK6s+gWZF6Pnsa
+o9jEecyL7bRJ2/s8CeOjBKHBkte3hE4xNEn0SwKBDeTHxSRMRrgWRWfTsHjx4yFU
+bND/y7LP2XMj1Aq5JwvuxhLJA7Mbz1UBuvfbnu1m1b3cCNMI/JBZRpL25ZKLyVkx
+C+fdIQKBgA+tLeF10zqGGc4269b6nQWplc5E/qnIRK0cfnKb9BtffmA4FbjUpZKj
++cGmbtbw7ySkAIKLp4HoJmzkXJageGTSEb/sQIodxMiJCGvvgJmPPnGzU8OiUGAl
+VmRjuAQ2eCcsUyvrJYgKW9UWskqSe6z5w/Uxo/sZdHlaGljNdKcn
 -----END RSA PRIVATE KEY-----

data/example/server.rb

@@ -31,9 +31,15 @@ loop do
 
   conn = HTTP2::Server.new
   conn.on(:frame) do |bytes|
-    puts "Writing bytes: #{bytes.inspect}"
+    # puts "Writing bytes: #{bytes.unpack("H*").first}"
     sock.write bytes
   end
+  conn.on(:frame_sent) do |frame|
+    puts "Sent frame: #{frame.inspect}"
+  end
+  conn.on(:frame_received) do |frame|
+    puts "Received frame: #{frame.inspect}"
+  end
 
   conn.on(:stream) do |stream|
     log = Logger.new(stream.id)
@@ -43,7 +49,7 @@ loop do
     stream.on(:close)  { log.info "stream closed" }
 
     stream.on(:headers) do |h|
-      req = h
+      req = Hash[*h.flatten]
       log.info "request headers: #{h}"
     end
 
@@ -56,7 +62,7 @@ loop do
       log.info "client closed its end of the stream"
 
       response = nil
-      if req[":method"] == "post"
+      if req[":method"] == "POST"
         log.info "Received POST request, payload: #{buffer}"
         response = "Hello HTTP 2.0! POST payload: #{buffer}"
       else
@@ -78,6 +84,7 @@ loop do
 
   while !sock.closed? && !sock.eof?
     data = sock.readpartial(1024)
+    # puts "Received bytes: #{data.unpack("H*").first}"
 
     begin
       conn << data

data/http-2.gemspec

@@ -6,7 +6,7 @@ require 'http/2/version'
 Gem::Specification.new do |spec|
   spec.name          = "http-2"
   spec.version       = HTTP2::VERSION
-  spec.authors       = ["Ilya Grigorik"]
+  spec.authors       = ["Ilya Grigorik", "Kaoru Maeda"]
   spec.email         = ["ilya@igvita.com"]
   spec.description   = "Pure-ruby HTTP 2.0 protocol implementation"
   spec.summary       = spec.description

data/lib/http/2.rb

@@ -3,6 +3,8 @@ require "http/2/error"
 require "http/2/emitter"
 require "http/2/buffer"
 require "http/2/flow_buffer"
+require "http/2/huffman"
+require "http/2/huffman_statemachine"
 require "http/2/compressor"
 require "http/2/framer"
 require "http/2/connection"

data/lib/http/2/client.rb

@@ -20,11 +20,12 @@ module HTTP2
   class Client < Connection
 
     # Initialize new HTTP 2.0 client object.
-    def initialize(*args)
+    def initialize(**settings)
       @stream_id    = 1
-      @state        = :connection_header
-      @compressor   = Header::Compressor.new(:request)
-      @decompressor = Header::Decompressor.new(:response)
+      @state        = :waiting_connection_preface
+
+      @local_role   = :client
+      @remote_role  = :server
 
       super
     end
@@ -33,18 +34,23 @@ module HTTP2
     # 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)
+      send_connection_preface
+      super(frame)
+    end
+
+    # Emit the connection preface if not yet
+    def send_connection_preface
+      if @state == :waiting_connection_preface
         @state = :connected
+        emit(:frame, CONNECTION_PREFACE_MAGIC)
 
-        settings(stream_limit: @stream_limit, window_limit: @window_limit)
+        payload = @local_settings.select {|k,v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k]}
+        settings(payload)
       end
-
-      super(frame)
     end
+
   end
 
 end

data/lib/http/2/compressor.rb

@@ -3,148 +3,179 @@ module HTTP2
   # 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
+  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09
   module Header
 
-    # The set of components used to encode or decode a header set form an
-    # encoding context: an encoding context contains a header table and a
-    # reference set - there is one encoding context for each direction.
-    #
+    BINARY = 'binary'
+
+    # To decompress header blocks, a decoder only needs to maintain a
+    # header table as a decoding context.
+    # No other state information is needed.
     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'  , ''     ],
-        ['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-range'               , ''   ],
-        ['link'                        , ''   ],
-        ['location'                    , ''   ],
-        ['proxy-authenticate'          , ''   ],
-        ['refresh'                     , ''   ],
-        ['retry-after'                 , ''   ],
-        ['strict-transport-security'   , ''   ],
-        ['transfer-encoding'           , ''   ],
-        ['www-authenticate'            , ''   ]
-      ]
+      # @private
+      # Static table
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#appendix-B
+      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',            ''            ],
+      ].freeze
 
       # Current table of header key-value pairs.
       attr_reader :table
 
-      # Current reference set of header key-value pairs.
-      attr_reader :refset
+      # Current encoding options
+      #
+      #   :table_size  Integer  maximum header 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 header table.
       #
-      # @param type [Symbol] either :request or :response
-      # @param limit [Integer] maximum header table size in bytes
-      def initialize(type, limit = 4096)
-        @type = type
-        @table = (type == :request) ? REQ_DEFAULTS.dup : RESP_DEFAULTS.dup
-        @limit = limit
-        @refset = []
+      # @param options [Hash] encoding options
+      #   :table_size  Integer  maximum header 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
 
-      # Performs differential coding based on provided command type.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-3.2
+      # Duplicates current compression context
+      # @return [EncodingContext]
+      def dup
+        other = EncodingContext.new(@options)
+        t = @table
+        l = @limit
+        other.instance_eval {
+          @table = t.dup              # shallow copy
+          @limit = l
+        }
+        other
+      end
+
+      # Finds an entry in current header table by index.
+      # Note that index is zero-based in this module.
       #
-      # @param cmd [Hash]
-      # @return [Hash] emitted header
+      # If the index is greater than the last index in the static table,
+      # an entry in the header 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 header table.
+      # @return [Array] +[key, value]+
+      def dereference(index)
+        # NOTE: index is zero-based in this module.
+        STATIC_TABLE[index] or
+          @table[index - STATIC_TABLE.size] or
+          raise CompressionError.new("Index too large")
+      end
+
+      # Header Block Processing
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-4.1
+      #
+      # @param cmd [Hash] { type:, name:, value:, index: }
+      # @return [Array] +[name, value]+ header field that is added to the decoded header list
       def process(cmd)
         emit = nil
 
-        # indexed representation
-        if cmd[:type] == :indexed
-          # 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.
-          #
+        case cmd[:type]
+        when :changetablesize
+          set_table_size(cmd[: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 header table is added to the decoded header
+          # list.
           idx = cmd[:name]
-          cur = @refset.find_index {|(i,v)| i == idx}
 
-          if cur
-            @refset.delete_at(cur)
-          else
-            emit = @table[idx]
-            @refset.push [idx, @table[idx]]
-          end
+          k, v = dereference(idx)
+          emit = [k, v]
 
-        else
-          # A literal representation that is not added to the header table
+        when :incremental, :noindex, :neverindexed
+          # 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.
-          #
+          # o  The header field is added to the decoded header list.
+
+          # A _literal representation_ that is _added_ to the header 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 header table.
+
           if cmd[:name].is_a? Integer
-            k,v = @table[cmd[:name]]
+            k, v = dereference(cmd[:name])
 
+            cmd = cmd.dup
             cmd[:index] ||= cmd[:name]
             cmd[:value] ||= v
             cmd[:name] = k
@@ -152,148 +183,167 @@ module HTTP2
 
           emit = [cmd[:name], cmd[:value]]
 
-          if cmd[:type] != :noindex
-            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
-
-              @table[cmd[:index]] = emit
-              @refset.push [cmd[:index], emit]
-            end
+          if cmd[:type] == :incremental
+            add_to_table(emit)
           end
+
+        else
+          raise CompressionError.new("Invalid type: #{cmd[:type]}")
         end
 
         emit
       end
 
-      # Emits best available command to encode provided header.
+      # Plan header compression according to +@options [:index]+
+      #  :never   Do not use header table or static table reference at all.
+      #  :static  Use static table only.
+      #  :all     Use all of them.
       #
-      # @param header [Hash]
+      # @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 |h|
+          cmd = addcmd(h)
+          if noindex && cmd[:type] == :incremental
+            cmd[:type] = :noindex
+          end
+          commands << cmd
+          process(cmd)
+        end
+        commands
+      end
+
+      # Emits command for a header.
+      # Prefer static table over header table.
+      # Prefer exact match over name-only match.
+      #
+      # +@options [:index]+ controls whether to use the header table,
+      # static table, or both.
+      #  :never   Do not use header 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 addcmd(header)
-        # check if we have an exact match in header table
-        if idx = @table.index(header)
-          if !active? idx
-            return { name: idx, type: :indexed }
+        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
 
-        # check if we have a partial match on header name
-        if idx = @table.index {|(k,_)| k == header.first}
-          # default to incremental indexing
-          cmd = { name: idx, value: header.last, type: :incremental}
-
-          # TODO: implement literal without indexing strategy
-          # TODO: implement substitution strategy (if it makes sense)
-          # if default? idx
-          #   cmd[:type] = :incremental
-          # else
-          #   cmd[:type] = :substitution
-          #   cmd[:index] = idx
-          # end
-
-          return cmd
+        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
 
-        return { name: header.first, value: header.last, type: :incremental }
+      # Alter header table size.
+      #  When the size is reduced, some headers might be evicted.
+      def set_table_size(size)
+        @limit = size
+        size_check(nil)
       end
 
-      # Emits command to remove current index from working set.
-      #
-      # @param idx [Integer]
-      def removecmd(idx)
-        {name: idx, type: :indexed}
+      # 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
 
-      # 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.
+      # Add a name-value pair to the header table.
+      # Older entries might have been evicted so that
+      # the new entry fits in the header table.
       #
-      # 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 [Array] +[name, value]+
+      def add_to_table(cmd)
+        if size_check(cmd)
+          @table.unshift(cmd)
+        end
+      end
+
+      # To keep the header table size lower than or equal to @limit,
+      # remove one or more entries at the end of the header table.
       #
       # @param cmd [Hash]
-      # @return [Boolean]
+      # @return [Boolean] whether +cmd+ fits in the header table.
       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 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
+        cursize = current_table_size
+        cmdsize = cmd.nil? ? 0 : cmd[0].bytesize + cmd[1].bytesize + 32
 
-        return true
-      end
+        while cursize + cmdsize > @limit do
+          break if @table.empty?
 
-      def active?(idx)
-        !@refset.find {|i,_| i == idx }.nil?
-      end
+          last_index = @table.size - 1
+          e = @table.pop
+          cursize -= e[0].bytesize + e[1].bytesize + 32
+        end
 
-      def default?(idx)
-        t = (@type == :request) ? REQ_DEFAULTS : RESP_DEFAULTS
-        idx < t.size
+        return cmdsize <= @limit
       end
     end
 
     # Header representation as defined by the spec.
     HEADREP = {
       indexed:      {prefix: 7, pattern: 0x80},
-      noindex:      {prefix: 5, pattern: 0x60},
-      incremental:  {prefix: 5, pattern: 0x40},
-      substitution: {prefix: 6, pattern: 0x00}
+      incremental:  {prefix: 6, pattern: 0x40},
+      noindex:      {prefix: 4, pattern: 0x00},
+      neverindexed: {prefix: 4, pattern: 0x10},
+      changetablesize: {prefix: 5, pattern: 0x20},
     }
 
+    # 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.
-    # Compressor must be initialized with appropriate starting context based
-    # on local role: client or server.
-    #
-    # @example
-    #   client_role = Compressor.new(:request)
-    #   server_role = Compressor.new(:response)
     class Compressor
-      def initialize(type)
-        @cc = EncodingContext.new(type)
+      # @param options [Hash] encoding options
+      def initialize(**options)
+        @cc = EncodingContext.new(options)
+      end
+
+      # Set header table size in EncodingContext
+      # @param size [Integer] new header table size
+      def set_table_size(size)
+        @cc.set_table_size(size)
       end
 
       # Encodes provided value via integer representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4.1.1
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-6.1
       #
       #  If I < 2^N - 1, encode I on N bits
       #  Else
@@ -325,31 +375,58 @@ module HTTP2
       end
 
       # Encodes provided value via string literal representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4.1.3
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-6.2
       #
       # * The string length, defined as the number of bytes needed to store
-      #   its UTF-8 representation, is represented as an integer with a zero
-      #   bits prefix. If the string length is strictly less than 128, it is
+      #   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.
-      # * The string value represented as a list of UTF-8 character
+      # * 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)
-        integer(str.bytesize, 0) << str.dup.force_encoding('binary')
+        plain, huffman = nil, nil
+        unless @cc.options[:huffman] == :always
+          plain = integer(str.bytesize, 7) << str.dup.force_encoding(BINARY)
+        end
+        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.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03#section-4
       #
       # @param h [Hash] header command
       # @param buffer [String]
+      # @return [Buffer]
       def header(h, buffer = Buffer.new)
         rep = HEADREP[h[:type]]
 
-        if h[:type] == :indexed
-          buffer << integer(h[:name], rep[:prefix])
-
+        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])
@@ -358,19 +435,11 @@ module HTTP2
             buffer << string(h[:name])
           end
 
-          if h[:type] == :substitution
-            buffer << integer(h[:index], 0)
-          end
-
-          if h[:value].is_a? Integer
-            buffer << integer(h[:value], 0)
-          else
-            buffer << string(h[:value])
-          end
+          buffer << string(h[:value])
         end
 
         # set header representation pattern on first byte
-        fb = buffer[0].unpack("C").first | rep[:pattern]
+        fb = buffer.ord | rep[:pattern]
         buffer.setbyte(0, fb)
 
         buffer
@@ -378,32 +447,17 @@ module HTTP2
 
       # Encodes provided list of HTTP headers.
       #
-      # @param headers [Hash]
+      # @param headers [Array] +[[name, value], ...]+
       # @return [Buffer]
       def encode(headers)
         buffer = Buffer.new
-        commands = []
 
         # 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
-
-        # Generate add commands for new headers
-        headers.each do |(hk,hv)|
-          if @cc.refset.find {|i,(wk,wv)| hk == wk && hv == wv}.nil?
-            commands.push @cc.addcmd [hk, hv]
-          end
-        end
+        headers.map! {|hk,hv| [hk.downcase, hv] }
 
+        commands = @cc.encode(headers)
         commands.each do |cmd|
-          @cc.process cmd.dup
           buffer << header(cmd)
         end
 
@@ -419,14 +473,22 @@ module HTTP2
     #   server_role = Decompressor.new(:request)
     #   client_role = Decompressor.new(:response)
     class Decompressor
-      def initialize(type)
-        @cc = EncodingContext.new(type)
+      # @param options [Hash] decoding options.  Only :table_size is effective.
+      def initialize(**options)
+        @cc = EncodingContext.new(options)
+      end
+
+      # Set header table size in EncodingContext
+      # @param size [Integer] new header table size
+      def set_table_size(size)
+        @cc.set_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
@@ -446,13 +508,21 @@ module HTTP2
       #
       # @param buf [String]
       # @return [String] UTF-8 encoded string
+      # @raise [CompressionError] when input is malformed
       def string(buf)
-        buf.read(integer(buf, 0)).force_encoding('utf-8')
+        huffman = (buf.readbyte(0) & 0x80) == 0x80
+        len = integer(buf, 7)
+        str = buf.read(len)
+        str.bytesize == len or raise CompressionError.new("string too short")
+        huffman and str = Huffman.new.decode(Buffer.new(str))
+        str = str.force_encoding('utf-8')
+        str
       end
 
       # Decodes header command from provided buffer.
       #
       # @param buf [Buffer]
+      # @return [Hash] command
       def header(buf)
         peek = buf.readbyte(0)
 
@@ -462,18 +532,22 @@ module HTTP2
           mask == desc[:pattern]
         end.first
 
+        header[:type] or raise CompressionError
+
         header[:name] = integer(buf, type[:prefix])
-        if header[:type] != :indexed
-          header[:name] -= 1
 
-          if header[:name] == -1
+        case header[:type]
+        when :indexed
+          header[:name] == 0 and raise CompressionError.new
+          header[:name] -= 1
+        when :changetablesize
+          header[:value] = header[:name]
+        else
+          if header[:name] == 0
             header[:name] = string(buf)
+          else
+            header[:name] -= 1
           end
-
-          if header[:type] == :substitution
-            header[:index] = integer(buf, 0)
-          end
-
           header[:value] = string(buf)
         end
 
@@ -482,26 +556,12 @@ module HTTP2
 
       # Decodes and processes header commands within provided buffer.
       #
-      # 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
+      # @return [Array] +[[name, value], ...]+
       def decode(buf)
-        set = []
-        set << @cc.process(header(buf)) while !buf.empty?
-        @cc.refset.each do |i,header|
-          set << header if !set.include? header
-        end
-
-        set.compact
+        list = []
+        list << @cc.process(header(buf)) while !buf.empty?
+        list.compact
       end
     end