kantan 0.0.0

data/examples/socket_abstraction.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+require 'stringio'
+require_relative '../lib/http2'
+
+# This example demonstrates how the HTTP/2 implementation is abstracted
+# from the underlying transport. You can pass ANY IO-like object that
+# supports read() and write() methods.
+
+puts "HTTP/2 Socket Abstraction Examples"
+puts "=" * 60
+
+# Example 1: Unix Domain Socket Pair
+puts "\n1. Unix Domain Socket Pair (for testing)"
+puts "-" * 60
+
+client_sock, server_sock = Socket.pair(:UNIX, :STREAM, 0)
+
+server_thread = Thread.new do
+  http2 = Kantan::Server.new(server_sock)
+  http2.on_stream do |stream|
+    http2.send_headers(stream.id, [[":status", "200"]])
+    http2.send_data(stream.id, "Response from Unix socket", end_stream: true)
+  end
+  http2.start
+end
+
+client_thread = Thread.new do
+  sleep 0.1
+  http2 = Kantan::Client.new(client_sock)
+  http2.on_data { |stream, data| puts "  Received: #{data}" }
+  http2.start
+  http2.request([[":method", "GET"], [":path", "/"], [":scheme", "https"], [":authority", "test"]])
+  Thread.new { http2.run }
+  sleep 0.5
+  http2.close
+end
+
+client_thread.join
+server_thread.join(1)
+
+client_sock.close rescue nil
+server_sock.close rescue nil
+
+# Example 2: TCP Socket
+puts "\n2. TCP Socket (standard network connection)"
+puts "-" * 60
+puts "  Server: Kantan::Server.new(tcp_socket)"
+puts "  Client: Kantan::Client.new(TCPSocket.new('host', port))"
+
+# Example 3: SSL/TLS Socket
+puts "\n3. SSL/TLS Socket (secure connection)"
+puts "-" * 60
+puts "  Server: Kantan::Server.new(ssl_socket)"
+puts "  Client: Kantan::Client.new(OpenSSL::SSL::SSLSocket.new(...))"
+puts "  See tls_example.rb for full implementation"
+
+# Example 4: Pipe (for IPC)
+puts "\n4. Pipe (inter-process communication)"
+puts "-" * 60
+
+reader, writer = IO.pipe
+writer.binmode
+reader.binmode
+
+fork_pid = fork do
+  writer.close
+  http2 = Kantan::Server.new(reader)
+  http2.on_stream do |stream|
+    http2.send_headers(stream.id, [[":status", "200"]])
+    http2.send_data(stream.id, "Response from pipe", end_stream: true)
+  end
+  http2.start
+  exit
+end
+
+reader.close
+
+http2_client = Kantan::Client.new(writer)
+response_data = nil
+
+http2_client.on_data do |stream, data|
+  response_data = data
+  puts "  Received: #{data}"
+end
+
+http2_client.start
+http2_client.request([[":method", "GET"], [":path", "/"], [":scheme", "https"], [":authority", "test"]])
+
+Thread.new { http2_client.run }
+sleep 0.5
+
+Process.wait(fork_pid)
+writer.close rescue nil
+
+# Example 5: Frame-level abstraction (using StringIO for testing)
+puts "\n5. Frame-level testing (using StringIO)"
+puts "-" * 60
+
+# Create a frame
+frame = Kantan::Frame.new(
+  type: :settings,
+  flags: 0,
+  stream_id: 0,
+  payload: ""
+)
+
+# Encode to binary
+binary = frame.to_binary
+puts "  Frame encoded: #{binary.bytesize} bytes"
+
+# Decode from binary using StringIO
+io = StringIO.new(binary)
+decoded_frame = Kantan::Frame.parse(io)
+puts "  Frame decoded: type=#{decoded_frame.type}, stream_id=#{decoded_frame.stream_id}"
+
+puts "\n" + "=" * 60
+puts "Key Takeaway: The HTTP/2 implementation works with ANY"
+puts "IO-like object (Socket, TCPSocket, SSLSocket, Pipe, etc.)"
+puts "as long as it supports read() and write() methods."
+puts "=" * 60

data/examples/tls.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+require 'openssl'
+require_relative '../lib/http2'
+
+# Example of using HTTP/2 with TLS/SSL
+# This demonstrates how to wrap sockets with SSL for secure HTTP/2
+
+def create_self_signed_cert
+  # Generate a self-signed certificate for testing
+  key = OpenSSL::PKey::RSA.new(2048)
+
+  cert = OpenSSL::X509::Certificate.new
+  cert.subject = cert.issuer = OpenSSL::X509::Name.parse("/C=US/O=Test/CN=localhost")
+  cert.not_before = Time.now
+  cert.not_after = Time.now + 365 * 24 * 60 * 60
+  cert.public_key = key.public_key
+  cert.serial = 0x0
+  cert.version = 2
+
+  # Add extensions
+  ef = OpenSSL::X509::ExtensionFactory.new
+  ef.subject_certificate = cert
+  ef.issuer_certificate = cert
+
+  cert.extensions = [
+    ef.create_extension("basicConstraints", "CA:TRUE", true),
+    ef.create_extension("subjectKeyIdentifier", "hash"),
+    ef.create_extension("subjectAltName", "DNS:localhost,IP:127.0.0.1")
+  ]
+
+  cert.sign(key, OpenSSL::Digest::SHA256.new)
+
+  [cert, key]
+end
+
+def run_tls_server
+  puts "Starting HTTP/2 over TLS server on port 8443..."
+
+  # Create TCP server
+  tcp_server = TCPServer.new(8443)
+
+  # Generate self-signed certificate
+  cert, key = create_self_signed_cert
+
+  # Setup SSL context
+  ssl_context = OpenSSL::SSL::SSLContext.new
+  ssl_context.cert = cert
+  ssl_context.key = key
+
+  # Enable HTTP/2 via ALPN (Application-Layer Protocol Negotiation)
+  ssl_context.alpn_protocols = ['h2']
+
+  # Create SSL server
+  ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ssl_context)
+
+  puts "Server ready. Waiting for connections..."
+  puts "ALPN protocols: #{ssl_context.alpn_protocols.inspect}"
+
+  loop do
+    # Accept SSL connection
+    ssl_socket = ssl_server.accept
+    puts "\nNew connection from #{ssl_socket.peeraddr[2]}"
+    puts "  Protocol: #{ssl_socket.alpn_protocol}"
+
+    # Verify HTTP/2 was negotiated
+    unless ssl_socket.alpn_protocol == 'h2'
+      puts "  Warning: HTTP/2 not negotiated, got: #{ssl_socket.alpn_protocol}"
+    end
+
+    Thread.new do
+      begin
+        # Create HTTP/2 server with the SSL socket
+        http2_server = Kantan::Server.new(ssl_socket)
+
+        http2_server.on_headers do |stream, headers|
+          puts "\n[Stream #{stream.id}] Headers:"
+          headers.each { |name, value| puts "  #{name}: #{value}" }
+        end
+
+        http2_server.on_stream do |stream|
+          method = stream.received_headers.find { |n, _| n == ":method" }&.last
+          path = stream.received_headers.find { |n, _| n == ":path" }&.last
+
+          puts "[Stream #{stream.id}] Request: #{method} #{path}"
+
+          # Generate response
+          body = "Secure HTTP/2 response!\n\nYou are connected via TLS.\n"
+          body += "Time: #{Time.now}\n"
+
+          response_headers = [
+            [":status", "200"],
+            ["content-type", "text/plain"],
+            ["content-length", body.bytesize.to_s],
+            ["server", "Pure Ruby HTTP/2 with TLS"]
+          ]
+
+          http2_server.send_headers(stream.id, response_headers)
+          http2_server.send_data(stream.id, body, end_stream: true)
+
+          puts "[Stream #{stream.id}] Response sent"
+        end
+
+        http2_server.start
+      rescue => e
+        puts "Error: #{e.message}"
+        puts e.backtrace[0..5]
+      ensure
+        ssl_socket.close unless ssl_socket.closed?
+      end
+    end
+  end
+rescue Interrupt
+  puts "\nShutting down server..."
+ensure
+  ssl_server&.close
+  tcp_server&.close
+end
+
+def run_tls_client
+  puts "Connecting to HTTP/2 over TLS server..."
+
+  # Create TCP socket
+  tcp_socket = TCPSocket.new('localhost', 8443)
+
+  # Setup SSL context
+  ssl_context = OpenSSL::SSL::SSLContext.new
+  ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE  # For self-signed cert
+  ssl_context.alpn_protocols = ['h2']
+
+  # Create SSL socket
+  ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+  ssl_socket.sync_close = true
+  ssl_socket.connect
+
+  puts "Connected via TLS"
+  puts "  Protocol: #{ssl_socket.alpn_protocol}"
+  puts "  Cipher: #{ssl_socket.cipher[0]}"
+
+  # Create HTTP/2 client with the SSL socket
+  http2_client = Kantan::Client.new(ssl_socket)
+
+  http2_client.on_headers do |stream, headers|
+    puts "\n[Stream #{stream.id}] Response headers:"
+    headers.each { |name, value| puts "  #{name}: #{value}" }
+  end
+
+  http2_client.on_data do |stream, data|
+    puts "\n[Stream #{stream.id}] Response body:"
+    puts data
+  end
+
+  # Start connection
+  http2_client.start
+
+  # Make request
+  puts "\nSending request..."
+  request_headers = [
+    [":method", "GET"],
+    [":path", "/secure"],
+    [":scheme", "https"],
+    [":authority", "localhost:8443"]
+  ]
+
+  stream = http2_client.request(request_headers)
+
+  # Run event loop
+  Thread.new { http2_client.run }
+
+  sleep 2
+
+  http2_client.close
+  puts "\nConnection closed"
+rescue => e
+  puts "Error: #{e.message}"
+  puts e.backtrace[0..5]
+end
+
+# Main
+if __FILE__ == $0
+  if ARGV[0] == 'server'
+    run_tls_server
+  elsif ARGV[0] == 'client'
+    run_tls_client
+  else
+    puts "HTTP/2 over TLS Example"
+    puts "=" * 60
+    puts
+    puts "Usage:"
+    puts "  ruby #{__FILE__} server    # Run the server"
+    puts "  ruby #{__FILE__} client    # Run the client"
+    puts
+    puts "To test:"
+    puts "  1. In one terminal: ruby #{__FILE__} server"
+    puts "  2. In another terminal: ruby #{__FILE__} client"
+    puts
+    puts "Or test with curl (if built with HTTP/2 support):"
+    puts "  curl -k --http2 https://localhost:8443/secure"
+    puts
+  end
+end

data/kantan.gemspec

@@ -0,0 +1,22 @@
+$: << File.expand_path("lib")
+
+require "kantan/version"
+
+Gem::Specification.new do |s|
+  s.name        = "kantan"
+  s.version     = Kantan::VERSION
+  s.summary     = "HTTP/2.0 parser written in Ruby"
+  s.description = "An HTTP/2.0 parser in Ruby"
+  s.authors     = ["Aaron Patterson"]
+  s.email       = "tenderlove@ruby-lang.org"
+  s.files       = `git ls-files -z`.split("\x0")
+  s.test_files  = s.files.grep(%r{^test/})
+  s.homepage    = "https://github.com/tenderlove/kantan"
+  s.license     = "Apache-2.0"
+
+  s.add_development_dependency 'minitest', '~> 5'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'logger', '~> 1.0'
+  s.add_development_dependency 'rack', '~> 3'
+  s.add_development_dependency 'concurrent-ruby', '~> 1.3'
+end

data/lib/kantan/errors.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Kantan
+  module Errors
+    class Error < StandardError; end
+
+    class ConnectionError < Error
+      attr_reader :remaining, :error_code
+
+      def initialize msg, remaining, error_code = 0x1
+        super(msg)
+        @remaining = remaining
+        @error_code = error_code
+      end
+    end
+
+    class ProtocolError < ConnectionError
+      def initialize msg, remaining
+        super(msg, remaining, 0x1)
+      end
+    end
+
+    class FrameSizeError < ConnectionError
+      def initialize msg, remaining
+        super(msg, remaining, 0x6)
+      end
+    end
+
+    class FlowControlError < ConnectionError
+      def initialize msg, remaining
+        super(msg, remaining, 0x3)
+      end
+    end
+
+    class StreamClosedError < ConnectionError
+      def initialize msg, remaining
+        super(msg, remaining, 0x5)
+      end
+    end
+
+    class CompressionError < ConnectionError
+      def initialize msg = "Compression error", remaining = 0
+        super(msg, remaining, 0x9)
+      end
+    end
+
+    class StreamError < Error
+      attr_reader :stream_id, :error_code, :remaining
+
+      def initialize msg, stream_id, remaining = 0, error_code = 0x1
+        super(msg)
+        @stream_id = stream_id
+        @remaining = remaining
+        @error_code = error_code
+      end
+    end
+
+    class StreamClosed < StreamError
+      def initialize msg, stream_id, remaining = 0
+        super(msg, stream_id, remaining, 0x5)
+      end
+    end
+
+    class RefusedStream < StreamError
+      def initialize msg, stream_id, remaining = 0
+        super(msg, stream_id, remaining, 0x7)
+      end
+    end
+  end
+end