plum 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e9aa768df8ce054c286452ca40c8e6f5671fda5
-  data.tar.gz: 3a5dafa95ec6dd94b6b354091a8eee73b88f3214
+  metadata.gz: aa11d64c7ed018b7ede5e9275adcd9abdb091003
+  data.tar.gz: 5fb20e87686039b5dec5f9b053719935b9788c06
 SHA512:
-  metadata.gz: 3110fdf853b9ab1a7966adff6b24a3665bf792853a63bc814e295cee3a343761894b2fa1a48157a19c349998415bfee7710f3242400081ea8863b48f30028d4f
-  data.tar.gz: 061d1e6292eb1cd9d2fc6cd6db1daceb4e483970c577cf504f23deb23a407e44535fa27c57a819159198f41c7b248c015940485bab620a565cca84b0a7f14620
+  metadata.gz: 1b0095b8f3510be4442524baadcb27a385530753ff0e63ea4eb80bd2ff1755757bbe913ac7977ded238dcb5cc46ad6e6830d720254640a59b4b5fd2e20f8ff1a
+  data.tar.gz: 87e4540bed0f1ec556b177fe16e208527acd43abcea2ef2edbd40fac3070348c7b74891b5d9acf5fe56dbca372940c5c4f771fc60ee05fd29dc26a1106f3ee89

data/README.md

@@ -4,11 +4,10 @@ A minimal implementation of HTTP/2 server.
 ## Requirements
 * OpenSSL 1.0.2+
 * Ruby 2.2 with [ALPN support](https://gist.github.com/rhenium/b1711edcc903e8887a51) and [ECDH support (r51348)](https://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/51348/diff?format=diff) or latest Ruby 2.3.0-dev.
+* [http-parser.rb gem](https://rubygems.org/gems/http_parser.rb) if you use "http" URI scheme.
 
 ## TODO
-* "http" URIs support (upgrade from HTTP/1.1)
-* Stream Priority (RFC 7540 5.3)
-* Better API
+* **Better API**
 
 ## License
 MIT License

data/examples/local_server.rb

@@ -11,6 +11,7 @@ CONTENT_TYPES = {
   /\.jpg$/ => "image/jpeg",
   /\.css$/ => "text/css",
   /\.js$/ => "application/javascript",
+  /\.atom$/ => "application/atom+xml",
 }
 
 $LOAD_PATH << File.expand_path("../../lib", __FILE__)

data/examples/non_tls_server.rb

@@ -0,0 +1,127 @@
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require "plum"
+require "socket"
+require "cgi"
+
+def log(con, stream, s)
+  prefix = "[%02x;%02x] " % [con, stream]
+  if s.is_a?(Enumerable)
+    puts s.map {|a| prefix + a.to_s }.join("\n")
+  else
+    puts prefix + s.to_s
+  end
+end
+
+tcp_server = TCPServer.new("0.0.0.0", 40080)
+
+loop do
+  begin
+    sock = tcp_server.accept
+    id = sock.fileno
+    puts "#{id}: accept!"
+  rescue => e
+    STDERR.puts e
+    next
+  end
+
+  plum = Plum::HTTPConnection.new(sock)
+
+  plum.on(:frame) do |frame|
+    log(id, frame.stream_id, "recv: #{frame.inspect}")
+  end
+
+  plum.on(:send_frame) do |frame|
+    log(id, frame.stream_id, "send: #{frame.inspect}")
+  end
+
+  plum.on(:connection_error) do |exception|
+    puts exception
+    puts exception.backtrace
+  end
+
+  plum.on(:stream) do |stream|
+    stream.on(:stream_error) do |exception|
+      puts exception
+      puts exception.backtrace
+    end
+
+    stream.on(:send_deferred) do |frame|
+      log(id, frame.stream_id, "send (deferred): #{frame.inspect}")
+    end
+
+    headers = data = nil
+
+    stream.on(:open) do
+      headers = nil
+      data = ""
+    end
+
+    stream.on(:headers) do |headers_|
+      log(id, stream.id, headers_.map {|name, value| "#{name}: #{value}" })
+      headers = headers_.to_h
+    end
+
+    stream.on(:data) do |data_|
+      log(id, stream.id, data_)
+      data << data_
+    end
+
+    stream.on(:end_stream) do
+      case [headers[":method"], headers[":path"]]
+      when ["GET", "/"]
+        body = "Hello World! <a href=/abc.html>ABC</a> <a href=/fgsd>Not found</a>"
+        body << <<-EOF
+        <form action=post.page method=post>
+        <input type=text name=key value=default_value>
+        <input type=submit>
+        </form>
+        EOF
+        stream.respond({
+          ":status": "200",
+          "server": "plum",
+          "content-type": "text/html",
+          "content-length": body.size
+        }, body)
+      when ["POST", "/post.page"]
+        body = "Posted value is: #{CGI.unescape(data).gsub("<", "&lt;").gsub(">", "&gt;")}<br> <a href=/>Back to top page</a>"
+        stream.respond({
+          ":status": "200",
+          "server": "plum",
+          "content-type": "text/html",
+          "content-length": body.size
+        }, body)
+      else
+        body = "Page not found! <a href=/>Back to top page</a>"
+        stream.respond({
+          ":status": "404",
+          "server": "plum",
+          "content-type": "text/html",
+          "content-length": body.size
+        }, body)
+      end
+    end
+  end
+
+  Thread.new {
+    begin
+      plum.run
+    rescue Plum::LegacyHTTPError
+      data = "Use modern web browser with HTTP/2 support."
+
+      resp = ""
+      resp << "HTTP/1.1 505 HTTP Version Not Supported\r\n"
+      resp << "Content-Type: text/plain\r\n"
+      resp << "Content-Length: #{data.bytesize}\r\n"
+      resp << "Server: plum/#{Plum::VERSION}\r\n"
+      resp << "\r\n"
+      resp << data
+
+      sock.write(resp)
+    rescue
+      puts $!
+      puts $!.backtrace
+    ensure
+      sock.close
+    end
+  }
+end

data/examples/static_server.rb

@@ -36,7 +36,7 @@ loop do
   begin
     sock = ssl_server.accept
     id = sock.io.fileno
-    puts "#{id}: accept!"
+    puts "#{id}: accept! #{sock.cipher.inspect}"
   rescue => e
     STDERR.puts e
     next

data/lib/plum.rb

@@ -1,5 +1,6 @@
 require "openssl"
 require "socket"
+require "base64"
 require "plum/version"
 require "plum/errors"
 require "plum/binary_string"

data/lib/plum/connection.rb

@@ -55,9 +55,7 @@ module Plum
       return if new_data.empty?
       @buffer << new_data
 
-      if @state == :negotiation
-        negotiate!
-      end
+      negotiate! if @state == :negotiation
 
       if @state != :negotiation
         while frame = Frame.parse!(@buffer)
@@ -87,8 +85,20 @@ module Plum
       @io.write(frame.assemble)
     end
 
+    def negotiate!
+      unless CLIENT_CONNECTION_PREFACE.start_with?(@buffer.byteslice(0, 24))
+        raise ConnectionError.new(:protocol_error) # (MAY) send GOAWAY. sending.
+      end
+
+      if @buffer.bytesize >= 24
+        @buffer.byteshift(24)
+        @state = :waiting_settings
+        settings(@local_settings)
+      end
+    end
+
     def new_stream(stream_id, **args)
-      if @streams.size > 0 && @streams.keys.last >= stream_id
+      if @streams.size > 0 && @streams.keys.max >= stream_id
         raise Plum::ConnectionError.new(:protocol_error)
       end
 
@@ -99,26 +109,25 @@ module Plum
     end
 
     def validate_received_frame(frame)
-      case @state
-      when :waiting_settings
-        raise ConnectionError.new(:protocol_error) if frame.type != :settings
-        @state = :negotiated
-        callback(:negotiated)
-      when :waiting_continuation
+      if @state == :waiting_settings && frame.type != :settings
+        raise ConnectionError.new(:protocol_error)
+      end
+
+      if @state == :waiting_continuation
         if frame.type != :continuation || frame.stream_id != @continuation_id
-          raise Plum::ConnectionError.new(:protocol_error)
+          raise ConnectionError.new(:protocol_error)
         end
 
         if frame.flags.include?(:end_headers)
           @state = :open
           @continuation_id = nil
         end
-      else
-        if [:headers].include?(frame.type)
-          if !frame.flags.include?(:end_headers)
-            @state = :waiting_continuation
-            @continuation_id = frame.stream_id
-          end
+      end
+
+      if [:headers].include?(frame.type)
+        if !frame.flags.include?(:end_headers)
+          @state = :waiting_continuation
+          @continuation_id = frame.stream_id
         end
       end
     end
@@ -133,9 +142,7 @@ module Plum
         if @streams.key?(frame.stream_id)
           stream = @streams[frame.stream_id]
         else
-          if frame.stream_id.even? # stream started by client must have odd ID
-            raise Plum::ConnectionError.new(:protocol_error)
-          end
+          raise ConnectionError.new(:protocol_error) if frame.stream_id.even? # stream started by client must have odd ID
           stream = new_stream(frame.stream_id)
         end
         stream.receive_frame(frame)
@@ -164,21 +171,27 @@ module Plum
       end
     end
 
-    def receive_settings(frame)
+    def receive_settings(frame, send_ack: true)
       if frame.flags.include?(:ack)
         raise ConnectionError.new(:frame_size_error) if frame.length != 0
+        callback(:settings_ack)
         return
+      else
+        raise ConnectionError.new(:frame_size_error) if frame.length % 6 != 0
       end
 
-      raise ConnectionError.new(:frame_size_error) if frame.length % 6 != 0
-
       old_remote_settings = @remote_settings.dup
       @remote_settings.merge!(frame.parse_settings)
       apply_remote_settings(old_remote_settings)
 
       callback(:remote_settings, @remote_settings, old_remote_settings)
 
-      send_immediately Frame.settings(:ack)
+      send_immediately Frame.settings(:ack) if send_ack
+
+      if @state == :waiting_settings
+        @state = :open
+        callback(:negotiated)
+      end
     end
 
     def apply_remote_settings(old_remote_settings)
@@ -190,10 +203,10 @@ module Plum
       raise Plum::ConnectionError.new(:frame_size_error) if frame.length != 8
 
       if frame.flags.include?(:ack)
-        on(:ping_ack)
+        callback(:ping_ack)
       else
-        on(:ping)
         opaque_data = frame.payload
+        callback(:ping, opaque_data)
         send_immediately Frame.ping(:ack, opaque_data)
       end
     end

data/lib/plum/errors.rb

@@ -1,5 +1,6 @@
 module Plum
   class Error < StandardError; end
+  class LegacyHTTPError < Error; end
   class HPACKError < Error; end
   class HTTPError < Error
     ERROR_CODES = {

data/lib/plum/hpack/encoder.rb

@@ -5,20 +5,23 @@ module Plum
     class Encoder
       include HPACK::Context
 
-      def initialize(dynamic_table_limit)
-        super
+      def initialize(dynamic_table_limit, indexing: true, huffman: true)
+        super(dynamic_table_limit)
+        @indexing = indexing
+        @huffman = huffman
       end
 
       def encode(headers)
         out = ""
         headers.each do |name, value|
-          name = name.to_s; value = value.to_s
+          name = name.to_s.b
+          value = value.to_s.b
           if index = search(name, value)
             out << encode_indexed(index)
           elsif index = search(name, nil)
-            out << encode_half_indexed(index, value, true) # incremental indexing
+            out << encode_half_indexed(index, value)
           else
-            out << encode_literal(name, value, true) # incremental indexing
+            out << encode_literal(name, value)
           end
         end
         out.force_encoding(Encoding::BINARY)
@@ -36,14 +39,14 @@ module Plum
       # +---+---------------------------+
       # | Value String (Length octets)  |
       # +-------------------------------+
-      def encode_literal(name, value, indexing = true)
-        if indexing
+      def encode_literal(name, value)
+        if @indexing
           store(name, value)
           fb = "\x40"
         else
           fb = "\x00"
         end
-        fb << encode_string(name) << encode_string(value)
+        fb.force_encoding(Encoding::BINARY) << encode_string(name) << encode_string(value)
       end
 
       # +---+---+---+---+---+---+---+---+
@@ -53,8 +56,8 @@ module Plum
       # +---+---------------------------+
       # | Value String (Length octets)  |
       # +-------------------------------+
-      def encode_half_indexed(index, value, indexing = true)
-        if indexing
+      def encode_half_indexed(index, value)
+        if @indexing
           store(fetch(index)[0], value)
           fb = encode_integer(index, 6)
           fb.setbyte(0, fb.uint8 | 0b01000000)
@@ -88,18 +91,29 @@ module Plum
           end
           out.push_uint8(value)
         end
+        out.force_encoding(Encoding::BINARY)
       end
 
       def encode_string(str)
-        huffman_str = Huffman.encode(str).force_encoding(__ENCODING__)
-        if huffman_str.bytesize < str.bytesize
-          lenstr = encode_integer(huffman_str.bytesize, 7)
-          lenstr.setbyte(0, lenstr.uint8(0) | 0b10000000)
-          lenstr << huffman_str
+        if @huffman
+          hs = encode_string_huffman(str)
+          ps = encode_string_plain(str)
+          hs.bytesize < ps.bytesize ? hs : ps
         else
-          encode_integer(str.bytesize, 7) << str
+          encode_string_plain(str)
         end
       end
+
+      def encode_string_plain(str)
+        encode_integer(str.bytesize, 7) << str.force_encoding(Encoding::BINARY)
+      end
+
+      def encode_string_huffman(str)
+        huffman_str = Huffman.encode(str)
+        lenstr = encode_integer(huffman_str.bytesize, 7)
+        lenstr.setbyte(0, lenstr.uint8(0) | 0b10000000)
+        lenstr.force_encoding(Encoding::BINARY) << huffman_str
+      end
     end
   end
 end

data/lib/plum/http_connection.rb

@@ -1,33 +1,76 @@
+using Plum::BinaryString
+
 module Plum
   class HTTPConnection < Connection
     def initialize(io, local_settings = {})
+      require "http/parser"
       super
+      @_headers = nil
+      @_body = ""
+      @_http_parser = setup_parser
     end
 
     private
     def negotiate!
-      if @buffer.bytesize >= 4
-        if CLIENT_CONNECTION_PREFACE.start_with?(@buffer)
-          negotiate_with_knowledge
+      super
+    rescue ConnectionError
+      # Upgrade from HTTP/1.1
+      offset = @_http_parser << @buffer
+      @buffer.byteshift(offset)
+    end
+
+    def setup_parser
+      parser = HTTP::Parser.new
+      parser.on_headers_complete = proc {|_headers|
+        @_headers = _headers.map {|n, v| [n.downcase, v] }.to_h
+      }
+      parser.on_body = proc {|chunk| @_body << chunk }
+      parser.on_message_complete = proc {|env|
+        connection = @_headers["connection"] || ""
+        upgrade = @_headers["upgrade"] || ""
+        settings = @_headers["http2-settings"]
+
+        if (connection.split(", ").sort == ["Upgrade", "HTTP2-Settings"].sort &&
+            upgrade.split(", ").include?("h2c") &&
+            settings != nil)
+          switch_protocol(settings)
         else
-          negotiate_with_upgrade
+          raise LegacyHTTPError.new
         end
-      end
-      # next
+      }
+
+      parser
     end
 
-    def negotiate_with_knowledge
-      if @buffer.bytesize >= 24
-        if @buffer.byteshift(24) == CLIENT_CONNECTION_PREFACE
-          @state = :waiting_settings
-          settings(@local_settings)
-        end
-      end
-      # next
+    def switch_protocol(settings)
+      self.on(:negotiated) {
+        _frame = Frame.new(type: :settings, stream_id: 0, payload: Base64.urlsafe_decode64(settings))
+        receive_settings(_frame, send_ack: false) # HTTP2-Settings
+        process_first_request
+      }
+
+      resp = ""
+      resp << "HTTP/1.1 101 Switching Protocols\r\n"
+      resp << "Connection: Upgrade\r\n"
+      resp << "Upgrade: h2c\r\n"
+      resp << "Server: plum/#{Plum::VERSION}\r\n"
+      resp << "\r\n"
+
+      io.write(resp)
     end
 
-    def negotiate_with_upgrade
-      raise NotImplementedError, "Parsing HTTP/1.1 is hard..."
+    def process_first_request
+      encoder = HPACK::Encoder.new(0, indexing: false) # don't pollute connection's HPACK context
+      stream = new_stream(1)
+      max_frame_size = local_settings[:max_frame_size]
+      headers = @_headers.merge({ ":method" => @_http_parser.http_method,
+                                  ":path" => @_http_parser.request_url,
+                                  ":authority" => @_headers["host"] })
+                         .reject {|n, v| ["connection", "http2-settings", "upgrade", "host"].include?(n) }
+
+      headers_s = Frame.headers(1, encoder.encode(headers), :end_headers).split_headers(max_frame_size) # stream ID is 1
+      data_s = Frame.data(1, @_body, :end_stream).split_data(max_frame_size)
+      (headers_s + data_s).each {|frag| stream.receive_frame(frag) }
     end
   end
 end

data/lib/plum/https_connection.rb

@@ -1,24 +1,31 @@
-using Plum::BinaryString
-
 module Plum
   class HTTPSConnection < Connection
     def initialize(io, local_settings = {})
-      super
-    end
-
-    private
-    def negotiate!
-      return if @buffer.empty?
-
-      if CLIENT_CONNECTION_PREFACE.start_with?(@buffer.byteslice(0, 24))
-        if @buffer.bytesize >= 24
-          @buffer.byteshift(24)
-          @state = :waiting_settings
-          settings(@local_settings)
+      if io.respond_to?(:cipher) # OpenSSL::SSL::SSLSocket-like
+        if CIPHER_BLACKLIST.include?(io.cipher.first) # [cipher-suite, ssl-version, keylen, alglen]
+          self.on(:negotiated) {
+            raise ConnectionError.new(:inadequate_security)
+          }
         end
-      else
-        raise ConnectionError.new(:protocol_error) # (MAY) send GOAWAY. sending.
       end
+
+      super
     end
+
+    CIPHER_BLACKLIST = %w(
+      NULL-MD5 NULL-SHA EXP-RC4-MD5 RC4-MD5 RC4-SHA EXP-RC2-CBC-MD5 IDEA-CBC-SHA EXP-DES-CBC-SHA DES-CBC-SHA DES-CBC3-SHA
+      DH-DSS-DES-CBC-SHA DH-DSS-DES-CBC3-SHA DH-RSA-DES-CBC-SHA DH-RSA-DES-CBC3-SHA EXP-EDH-DSS-DES-CBC-SHA EDH-DSS-DES-CBC-SHA EDH-DSS-DES-CBC3-SHA EXP-EDH-RSA-DES-CBC-SHA EDH-RSA-DES-CBC-SHA EDH-RSA-DES-CBC3-SHA
+      EXP-ADH-RC4-MD5 ADH-RC4-MD5 EXP-ADH-DES-CBC-SHA ADH-DES-CBC-SHA ADH-DES-CBC3-SHA AES128-SHA DH-DSS-AES128-SHA DH-RSA-AES128-SHA DHE-DSS-AES128-SHA DHE-RSA-AES128-SHA
+      ADH-AES128-SHA AES256-SHA DH-DSS-AES256-SHA DH-RSA-AES256-SHA DHE-DSS-AES256-SHA DHE-RSA-AES256-SHA ADH-AES256-SHA NULL-SHA256 AES128-SHA256 AES256-SHA256
+      DH-DSS-AES128-SHA256 DH-RSA-AES128-SHA256 DHE-DSS-AES128-SHA256 CAMELLIA128-SHA DH-DSS-CAMELLIA128-SHA DH-RSA-CAMELLIA128-SHA DHE-DSS-CAMELLIA128-SHA DHE-RSA-CAMELLIA128-SHA ADH-CAMELLIA128-SHA DHE-RSA-AES128-SHA256
+      DH-DSS-AES256-SHA256 DH-RSA-AES256-SHA256 DHE-DSS-AES256-SHA256 DHE-RSA-AES256-SHA256 ADH-AES128-SHA256 ADH-AES256-SHA256 CAMELLIA256-SHA DH-DSS-CAMELLIA256-SHA DH-RSA-CAMELLIA256-SHA DHE-DSS-CAMELLIA256-SHA
+      DHE-RSA-CAMELLIA256-SHA ADH-CAMELLIA256-SHA PSK-RC4-SHA PSK-3DES-EDE-CBC-SHA PSK-AES128-CBC-SHA PSK-AES256-CBC-SHA SEED-SHA DH-DSS-SEED-SHA DH-RSA-SEED-SHA DHE-DSS-SEED-SHA
+      DHE-RSA-SEED-SHA ADH-SEED-SHA AES128-GCM-SHA256 AES256-GCM-SHA384 DH-RSA-AES128-GCM-SHA256 DH-RSA-AES256-GCM-SHA384 DH-DSS-AES128-GCM-SHA256 DH-DSS-AES256-GCM-SHA384 ADH-AES128-GCM-SHA256 ADH-AES256-GCM-SHA384
+      ECDH-ECDSA-NULL-SHA ECDH-ECDSA-RC4-SHA ECDH-ECDSA-DES-CBC3-SHA ECDH-ECDSA-AES128-SHA ECDH-ECDSA-AES256-SHA ECDHE-ECDSA-NULL-SHA ECDHE-ECDSA-RC4-SHA ECDHE-ECDSA-DES-CBC3-SHA ECDHE-ECDSA-AES128-SHA ECDHE-ECDSA-AES256-SHA
+      ECDH-RSA-NULL-SHA ECDH-RSA-RC4-SHA ECDH-RSA-DES-CBC3-SHA ECDH-RSA-AES128-SHA ECDH-RSA-AES256-SHA ECDHE-RSA-NULL-SHA ECDHE-RSA-RC4-SHA ECDHE-RSA-DES-CBC3-SHA ECDHE-RSA-AES128-SHA ECDHE-RSA-AES256-SHA
+      AECDH-NULL-SHA AECDH-RC4-SHA AECDH-DES-CBC3-SHA AECDH-AES128-SHA AECDH-AES256-SHA SRP-3DES-EDE-CBC-SHA SRP-RSA-3DES-EDE-CBC-SHA SRP-DSS-3DES-EDE-CBC-SHA SRP-AES-128-CBC-SHA SRP-RSA-AES-128-CBC-SHA
+      SRP-DSS-AES-128-CBC-SHA SRP-AES-256-CBC-SHA SRP-RSA-AES-256-CBC-SHA SRP-DSS-AES-256-CBC-SHA ECDHE-ECDSA-AES128-SHA256 ECDHE-ECDSA-AES256-SHA384 ECDH-ECDSA-AES128-SHA256 ECDH-ECDSA-AES256-SHA384 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES256-SHA384
+      ECDH-RSA-AES128-SHA256 ECDH-RSA-AES256-SHA384 ECDH-ECDSA-AES128-GCM-SHA256 ECDH-ECDSA-AES256-GCM-SHA384 ECDH-RSA-AES128-GCM-SHA256 ECDH-RSA-AES256-GCM-SHA384
+    )
   end
 end

data/lib/plum/version.rb

@@ -1,3 +1,3 @@
 module Plum
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/plum.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "http_parser.rb"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "minitest", "~> 5.7.0"

data/test/plum/hpack/test_context.rb

@@ -54,10 +54,10 @@ class HPACKContextTest < Minitest::Test
 
   private
   def new_context(limit = 1 << 31)
-    @c ||= Class.new {
+    klass = Class.new {
       include Plum::HPACK::Context
       public *Plum::HPACK::Context.private_instance_methods
     }
-    @c.new(limit)
+    klass.new(limit)
   end
 end

data/test/plum/hpack/test_encoder.rb

@@ -3,25 +3,25 @@ require "test_helper"
 class HPACKEncoderTest < Minitest::Test
   # C.1.1
   def test_hpack_encode_integer_small
-    result = new_encoder.__send__(:encode_integer, 10, 5)
+    result = new_encoder(1 << 31).__send__(:encode_integer, 10, 5)
     assert_equal([0b00001010].pack("C*"), result)
   end
 
   # C.1.2
   def test_hpack_encode_integer_big
-    result = new_encoder.__send__(:encode_integer, 1337, 5)
+    result = new_encoder(1 << 31).__send__(:encode_integer, 1337, 5)
     assert_equal([0b00011111, 0b10011010, 0b00001010].pack("C*"), result)
   end
 
   # C.1.3
   def test_hpack_encode_integer_8prefix
-    result = new_encoder.__send__(:encode_integer, 42, 8)
+    result = new_encoder(1 << 31).__send__(:encode_integer, 42, 8)
     assert_equal([0b00101010].pack("C*"), result)
   end
 
   def test_hpack_encode_single
     headers = [["custom-key", "custom-header"]]
-    encoded = new_encoder.encode(headers)
+    encoded = new_encoder(1 << 31).encode(headers)
     decoded = new_decoder.decode(encoded)
     assert_equal(headers, decoded)
   end
@@ -33,17 +33,34 @@ class HPACKEncoderTest < Minitest::Test
       [":path", "/"],
       [":authority", "www.example.com"]
     ]
-    encoded = new_encoder.encode(headers)
+    encoded = new_encoder(1 << 31).encode(headers)
     decoded = new_decoder.decode(encoded)
     assert_equal(headers, decoded)
   end
 
+  def test_hpack_encode_without_indexing
+    encoder = new_encoder(1 << 31, indexing: false)
+    headers1 = [["custom-key", "custom-header"]]
+    ret1 = encoder.encode(headers1)
+    assert_equal([], encoder.dynamic_table)
+    headers2 = [[":method", "custom-header"]]
+    ret2 = encoder.encode(headers2)
+    assert_equal([], encoder.dynamic_table)
+  end
+
+  def test_hpack_encode_without_huffman
+    encoder = new_encoder(1 << 31, huffman: false)
+    headers = [["custom-key", "custom-header"]]
+    ret = encoder.encode(headers)
+    assert_equal("\x40\x0acustom-key\x0dcustom-header", ret)
+  end
+
   private
   def new_decoder(settings_header_table_size = 1 << 31)
     Plum::HPACK::Decoder.new(settings_header_table_size)
   end
 
-  def new_encoder(settings_header_table_size = 1 << 31)
-    Plum::HPACK::Encoder.new(settings_header_table_size)
+  def new_encoder(*args)
+    Plum::HPACK::Encoder.new(*args)
   end
 end

data/test/plum/stream/test_handle_frame.rb

@@ -160,7 +160,7 @@ class StreamHandleFrameTest < Minitest::Test
       header_block = HPACK::Encoder.new(0).encode([[":path", "/"]])
       payload = "".push_uint32((1 << 31) | parent.id)
                   .push_uint8(50)
-                  .push(header_block)
+        .push(header_block)
       stream.receive_frame(Frame.new(type: :headers,
                                      stream_id: stream.id,
                                      flags: [:end_headers, :priority],

data/test/plum/test_event_emitter.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+using BinaryString
+class EventEmitterTest < Minitest::Test
+  def test_simple
+    ret = nil
+    emitter = new_emitter
+    emitter.on(:event) {|arg| ret = arg }
+    emitter.callback(:event, 123)
+    assert_equal(123, ret)
+  end
+
+  def test_multiple
+    ret1 = nil; ret2 = nil
+    emitter = new_emitter
+    emitter.on(:event) {|arg| ret1 = arg }
+    emitter.on(:event) {|arg| ret2 = arg }
+    emitter.callback(:event, 123)
+    assert_equal(123, ret1)
+    assert_equal(123, ret2)
+  end
+
+  private
+  def new_emitter
+    klass = Class.new {
+      include EventEmitter
+      public *EventEmitter.private_instance_methods
+    }
+    klass.new
+  end
+end

data/test/plum/test_http_connection.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+using Plum::BinaryString
+
+class HTTPConnectionNegotiationTest < Minitest::Test
+  ## with Prior Knowledge (same as over TLS)
+  def test_server_must_raise_cprotocol_error_non_settings_after_magic
+    con = HTTPConnection.new(StringIO.new)
+    con << Connection::CLIENT_CONNECTION_PREFACE
+    assert_connection_error(:protocol_error) {
+      con << Frame.new(type: :window_update, stream_id: 0, payload: "".push_uint32(1)).assemble
+    }
+  end
+
+  def test_server_accept_fragmented_magic
+    magic = Connection::CLIENT_CONNECTION_PREFACE
+    con = HTTPConnection.new(StringIO.new)
+    assert_no_error {
+      con << magic[0...5]
+      con << magic[5..-1]
+      con << Frame.new(type: :settings, stream_id: 0).assemble
+    }
+  end
+
+  ## with HTTP/1.1 Upgrade
+  def test_server_accept_upgrade
+    io = StringIO.new
+    con = HTTPConnection.new(io)
+    heads = nil
+    con.on(:stream) {|stream|
+      stream.on(:headers) {|_h| heads = _h.to_h }
+    }
+    req = "GET / HTTP/1.1\r\n" <<
+          "Host: rhe.jp\r\n" <<
+          "User-Agent: nya\r\n" <<
+          "Upgrade: h2c\r\n" <<
+          "Connection: HTTP2-Settings, Upgrade\r\n" <<
+          "HTTP2-Settings: \r\n" <<
+          "\r\n"
+    con << req
+    assert(io.string.include?("HTTP/1.1 101 "), "Response is not HTTP/1.1 101: #{io.string}")
+    assert_no_error {
+      con << Connection::CLIENT_CONNECTION_PREFACE
+      con << Frame.new(type: :settings, stream_id: 0).assemble
+    }
+    assert_equal(:half_closed_remote, con.streams[1].state)
+    assert_equal({ ":method" => "GET", ":path" => "/", ":authority" => "rhe.jp", "user-agent" => "nya"}, heads)
+  end
+
+  def test_server_deny_non_upgrade
+    io = StringIO.new
+    con = HTTPConnection.new(io)
+    req = "GET / HTTP/1.1\r\n" <<
+          "Host: rhe.jp\r\n" <<
+          "User-Agent: nya\r\n" <<
+          "Connection: close\r\n" <<
+          "\r\n"
+    assert_raises(LegacyHTTPError) {
+      con << req
+    }
+  end
+end

data/test/plum/test_https_connection.rb

@@ -34,4 +34,55 @@ class HTTPSConnectionNegotiationTest < Minitest::Test
       con << Frame.new(type: :settings, stream_id: 0).assemble
     }
   end
+
+  def test_inadequate_security_ssl_socket
+    run = false
+
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.alpn_select_cb = -> protocols { "h2" }
+    ctx.cert = OpenSSL::X509::Certificate.new File.read(File.expand_path("../../server.crt", __FILE__))
+    ctx.key = OpenSSL::PKey::RSA.new File.read(File.expand_path("../../server.key", __FILE__))
+    tcp_server = TCPServer.new("127.0.0.1", LISTEN_PORT)
+    ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
+
+    server_thread = Thread.new {
+      begin
+        timeout(3) {
+          sock = ssl_server.accept
+          plum = HTTPSConnection.new(sock)
+          assert_connection_error(:inadequate_security) {
+            run = true
+            plum.run
+          }
+        }
+      rescue TimeoutError
+        flunk "server timeout"
+      ensure
+        tcp_server.close
+      end
+    }
+    client_thread = Thread.new {
+      sock = TCPSocket.new("127.0.0.1", LISTEN_PORT)
+      begin
+        timeout(3) {
+          ctx = OpenSSL::SSL::SSLContext.new.tap {|ctx|
+            ctx.alpn_protocols = ["h2"]
+            ctx.ciphers = "AES256-GCM-SHA384"
+          }
+          ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+          ssl.connect
+          ssl.write Connection::CLIENT_CONNECTION_PREFACE
+          ssl.write Frame.settings.assemble
+        }
+      rescue TimeoutError
+        flunk "client timeout"
+      ensure
+        sock.close
+      end
+    }
+    client_thread.join
+    server_thread.join
+
+    flunk "test not run" unless run
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plum
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - rhenium
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2015-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -138,6 +152,7 @@ files:
 - Rakefile
 - bin/.gitkeep
 - examples/local_server.rb
+- examples/non_tls_server.rb
 - examples/static_server.rb
 - lib/plum.rb
 - lib/plum/binary_string.rb
@@ -170,10 +185,12 @@ files:
 - test/plum/test_connection.rb
 - test/plum/test_connection_utils.rb
 - test/plum/test_error.rb
+- test/plum/test_event_emitter.rb
 - test/plum/test_flow_control.rb
 - test/plum/test_frame.rb
 - test/plum/test_frame_factory.rb
 - test/plum/test_frame_utils.rb
+- test/plum/test_http_connection.rb
 - test/plum/test_https_connection.rb
 - test/plum/test_stream.rb
 - test/plum/test_stream_utils.rb
@@ -203,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A minimal implementation of HTTP/2 server.
@@ -218,10 +235,12 @@ test_files:
 - test/plum/test_connection.rb
 - test/plum/test_connection_utils.rb
 - test/plum/test_error.rb
+- test/plum/test_event_emitter.rb
 - test/plum/test_flow_control.rb
 - test/plum/test_frame.rb
 - test/plum/test_frame_factory.rb
 - test/plum/test_frame_utils.rb
+- test/plum/test_http_connection.rb
 - test/plum/test_https_connection.rb
 - test/plum/test_stream.rb
 - test/plum/test_stream_utils.rb