mieps_http-2 0.8.0

data/example/keys/mykey.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+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

@@ -0,0 +1,97 @@
+require_relative 'helper'
+
+options = { port: 8080 }
+OptionParser.new do |opts|
+  opts.banner = 'Usage: server.rb [options]'
+
+  opts.on('-s', '--secure', 'HTTPS mode') do |v|
+    options[:secure] = v
+  end
+
+  opts.on('-p', '--port [Integer]', 'listen port') do |v|
+    options[:port] = v
+  end
+end.parse!
+
+puts "Starting server on port #{options[:port]}"
+server = TCPServer.new(options[:port])
+
+if options[:secure]
+  ctx = OpenSSL::SSL::SSLContext.new
+  ctx.cert = OpenSSL::X509::Certificate.new(File.open('keys/mycert.pem'))
+  ctx.key = OpenSSL::PKey::RSA.new(File.open('keys/mykey.pem'))
+  ctx.npn_protocols = [DRAFT]
+
+  server = OpenSSL::SSL::SSLServer.new(server, ctx)
+end
+
+loop do
+  sock = server.accept
+  puts 'New TCP connection!'
+
+  conn = HTTP2::Server.new
+  conn.on(:frame) do |bytes|
+    # 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)
+    req, buffer = {}, ''
+
+    stream.on(:active) { log.info 'cliend opened new stream' }
+    stream.on(:close)  { log.info 'stream closed' }
+
+    stream.on(:headers) do |h|
+      req = Hash[*h.flatten]
+      log.info "request headers: #{h}"
+    end
+
+    stream.on(:data) do |d|
+      log.info "payload chunk: <<#{d}>>"
+      buffer << d
+    end
+
+    stream.on(:half_close) do
+      log.info 'client closed its end of the stream'
+
+      response = nil
+      if req[':method'] == 'POST'
+        log.info "Received POST request, payload: #{buffer}"
+        response = "Hello HTTP 2.0! POST payload: #{buffer}"
+      else
+        log.info 'Received GET request'
+        response = 'Hello HTTP 2.0! GET request'
+      end
+
+      stream.headers({
+        ':status' => '200',
+        'content-length' => response.bytesize.to_s,
+        'content-type' => 'text/plain',
+      }, end_stream: false)
+
+      # split response into multiple DATA frames
+      stream.data(response.slice!(0, 5), end_stream: false)
+      stream.data(response)
+    end
+  end
+
+  while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
+    data = sock.readpartial(1024)
+    # puts "Received bytes: #{data.unpack("H*").first}"
+
+    begin
+      conn << data
+    rescue => e
+      puts "#{e.class} exception: #{e.message} - closing socket."
+      e.backtrace.each { |l| puts "\t" + l }
+      sock.close
+    end
+  end
+end

data/example/upgrade_server.rb

@@ -0,0 +1,193 @@
+require_relative 'helper'
+require 'http_parser'
+require 'base64'
+
+options = { port: 8080 }
+OptionParser.new do |opts|
+  opts.banner = 'Usage: server.rb [options]'
+
+  opts.on('-s', '--secure', 'HTTPS mode') do |v|
+    options[:secure] = v
+  end
+
+  opts.on('-p', '--port [Integer]', 'listen port') do |v|
+    options[:port] = v
+  end
+end.parse!
+
+puts "Starting server on port #{options[:port]}"
+server = TCPServer.new(options[:port])
+
+if options[:secure]
+  ctx = OpenSSL::SSL::SSLContext.new
+  ctx.cert = OpenSSL::X509::Certificate.new(File.open('keys/mycert.pem'))
+  ctx.key = OpenSSL::PKey::RSA.new(File.open('keys/mykey.pem'))
+  ctx.npn_protocols = [DRAFT]
+
+  server = OpenSSL::SSL::SSLServer.new(server, ctx)
+end
+
+class UpgradeHandler
+  VALID_UPGRADE_METHODS = %w(GET OPTIONS)
+  UPGRADE_RESPONSE = <<-RESP
+HTTP/1.1 101 Switching Protocols
+Connection: Upgrade
+Upgrade: h2c
+
+RESP
+
+  attr_reader :complete, :headers, :body, :parsing
+
+  def initialize(conn, sock)
+    @conn, @sock = conn, sock
+    @complete, @parsing = false, false
+    @body = ''
+    @parser = ::HTTP::Parser.new(self)
+  end
+
+  def <<(data)
+    @parsing ||= true
+    @parser << data
+    return unless complete
+
+    @sock.write UPGRADE_RESPONSE
+
+    settings = headers['http2-settings']
+    request = {
+      ':scheme'    => 'http',
+      ':method'    => @parser.http_method,
+      ':authority' => headers['Host'],
+      ':path'      => @parser.request_url,
+    }.merge(headers)
+
+    @conn.upgrade(settings, request, @body)
+  end
+
+  def complete!
+    @complete = true
+  end
+
+  def on_headers_complete(headers)
+    @headers = headers
+  end
+
+  def on_body(chunk)
+    @body << chunk
+  end
+
+  def on_message_complete
+    fail unless VALID_UPGRADE_METHODS.include?(@parser.http_method)
+    @parsing = false
+    complete!
+  end
+end
+
+loop do
+  sock = server.accept
+  puts 'New TCP connection!'
+
+  conn = HTTP2::Server.new
+  conn.on(:frame) do |bytes|
+    # 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)
+    req, buffer = {}, ''
+
+    stream.on(:active) { log.info 'client opened new stream' }
+    stream.on(:close) do
+      log.info 'stream closed'
+    end
+
+    stream.on(:headers) do |h|
+      req = Hash[*h.flatten]
+      log.info "request headers: #{h}"
+    end
+
+    stream.on(:data) do |d|
+      log.info "payload chunk: <<#{d}>>"
+      buffer << d
+    end
+
+    stream.on(:half_close) do
+      log.info 'client closed its end of the stream'
+
+      if req['Upgrade']
+        log.info "Processing h2c Upgrade request: #{req}"
+
+        # Don't respond to OPTIONS...
+        if req[':method'] != 'OPTIONS'
+          response = 'Hello h2c world!'
+          stream.headers({
+            ':status' => '200',
+            'content-length' => response.bytesize.to_s,
+            'content-type' => 'text/plain',
+          }, end_stream: false)
+          stream.data(response)
+        end
+      else
+
+        response = nil
+        if req[':method'] == 'POST'
+          log.info "Received POST request, payload: #{buffer}"
+          response = "Hello HTTP 2.0! POST payload: #{buffer}"
+        else
+          log.info 'Received GET request'
+          response = 'Hello HTTP 2.0! GET request'
+        end
+
+        stream.headers({
+          ':status' => '200',
+          'content-length' => response.bytesize.to_s,
+          'content-type' => 'text/plain',
+        }, end_stream: false)
+
+        # split response into multiple DATA frames
+        stream.data(response.slice!(0, 5), end_stream: false)
+        stream.data(response)
+      end
+    end
+  end
+
+  uh = UpgradeHandler.new(conn, sock)
+
+  while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
+    data = sock.readpartial(1024)
+    # puts "Received bytes: #{data.unpack("H*").first}"
+
+    begin
+      case
+      when !uh.parsing && !uh.complete
+
+        if data.start_with?(*UpgradeHandler::VALID_UPGRADE_METHODS)
+          uh << data
+        else
+          uh.complete!
+          conn << data
+        end
+
+      when uh.parsing && !uh.complete
+        uh << data
+
+      when uh.complete
+        conn << data
+      end
+
+    rescue => e
+      puts "Exception: #{e}, #{e.message} - closing socket."
+      puts e.backtrace.last(10).join("\n")
+      sock.close
+    end
+  end
+end
+
+# echo foo=bar | nghttp -d - -t 0 -vu http://127.0.0.1:8080/
+# nghttp -vu http://127.0.0.1:8080/

data/http-2.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http/2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mieps_http-2'
+  spec.version       = HTTP2::VERSION
+  spec.authors       = ['Ilya Grigorik', 'Kaoru Maeda']
+  spec.email         = ['ilya@igvita.com']
+  spec.description   = 'Fork of Pure-ruby HTTP 2.0 protocol implementation - https://github.com/igrigorik/http-2'
+  spec.summary       = spec.description
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>=2.1.0'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+end

data/lib/http/2/buffer.rb

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

data/lib/http/2/client.rb

@@ -0,0 +1,51 @@
+module HTTP2
+  # HTTP 2.0 client connection class that implements appropriate header
+  # compression / decompression algorithms and stream management logic.
+  #
+  # Your code is responsible for driving the client object, which in turn
+  # performs all of the necessary HTTP 2.0 encoding / decoding, state
+  # management, and the rest. A simple example:
+  #
+  # @example
+  #     socket = YourTransport.new
+  #
+  #     conn = HTTP2::Client.new
+  #     conn.on(:frame) {|bytes| socket << bytes }
+  #
+  #     while bytes = socket.read
+  #       conn << bytes
+  #     end
+  #
+  class Client < Connection
+    # Initialize new HTTP 2.0 client object.
+    def initialize(**settings)
+      @stream_id    = 1
+      @state        = :waiting_connection_preface
+
+      @local_role   = :client
+      @remote_role  = :server
+
+      super
+    end
+
+    # Send an outgoing frame. Connection and stream flow control is managed
+    # by Connection class.
+    #
+    # @see Connection
+    # @param frame [Hash]
+    def send(frame)
+      send_connection_preface
+      super(frame)
+    end
+
+    # Emit the connection preface if not yet
+    def send_connection_preface
+      return unless @state == :waiting_connection_preface
+      @state = :connected
+      emit(:frame, CONNECTION_PREFACE_MAGIC)
+
+      payload = @local_settings.select { |k, v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
+      settings(payload)
+    end
+  end
+end