quicsilver 0.1.0 → 0.3.0

data/lib/quicsilver/server/listener_data.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    class ListenerData
+      attr_reader :listener_handle, :context_handle
+
+      def initialize(listener_handle, context_handle)
+        @listener_handle = listener_handle  # The MSQUIC listener handle
+        @context_handle = context_handle    # The C context pointer
+      end
+    end
+  end
+end

data/lib/quicsilver/server/request_handler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    class RequestHandler
+      # Safe HTTP methods allowed in 0-RTT early data (RFC 9110 §9.2.1)
+      SAFE_METHODS = %w[GET HEAD OPTIONS].freeze
+
+      def initialize(app:, configuration:, request_registry:, cancelled_streams:, cancelled_mutex:)
+        @app = app
+        @configuration = configuration
+        @request_registry = request_registry
+        @cancelled_streams = cancelled_streams
+        @cancelled_mutex = cancelled_mutex
+      end
+
+      def call(connection, stream, early_data: false)
+        parser = Protocol::RequestParser.new(
+          stream.data,
+          max_body_size: @configuration.max_body_size,
+          max_header_size: @configuration.max_header_size,
+          max_header_count: @configuration.max_header_count,
+          max_frame_payload_size: @configuration.max_frame_payload_size
+        )
+        parser.parse
+        parser.validate_headers!  # raises MessageError for missing/invalid pseudo-headers
+        env = parser.to_rack_env
+
+        if env && @app
+          env["quicsilver.early_data"] = early_data
+
+          # RFC 8470: reject unsafe methods on 0-RTT unless app opted in
+          if @configuration.early_data_policy == :reject &&
+             early_data && !SAFE_METHODS.include?(env["REQUEST_METHOD"])
+            connection.send_error(stream, 425, "Too Early") if stream.writable?
+            return
+          end
+
+          @request_registry.track(
+            stream.stream_id,
+            connection.handle,
+            path: env["PATH_INFO"] || "/",
+            method: env["REQUEST_METHOD"] || "GET"
+          )
+
+          status, headers, body = @app.call(env)
+
+          if cancelled_stream?(stream.stream_id)
+            Quicsilver.logger.debug("Skipping response for cancelled stream #{stream.stream_id}")
+            return
+          end
+
+          raise "Stream handle not found for stream #{stream.stream_id}" unless stream.writable?
+
+          connection.send_response(stream, status, headers, body, head_request: env["REQUEST_METHOD"] == "HEAD")
+          @request_registry.complete(stream.stream_id)
+        else
+          connection.send_error(stream, 400, "Bad Request") if stream.writable?
+        end
+      rescue Server::DrainTimeoutError
+        Quicsilver.logger.debug("Request interrupted by drain: stream #{stream.stream_id}")
+      rescue Protocol::FrameError => e
+        # Frame errors are connection-level: signal via CONNECTION_CLOSE with H3 error code
+        Quicsilver.logger.error("Frame error: #{e.message} (0x#{e.error_code.to_s(16)})")
+        Quicsilver.connection_shutdown(connection.handle, e.error_code, false) rescue nil
+      rescue Protocol::MessageError => e
+        # Message errors are stream-level: signal via RESET_STREAM with H3 error code
+        Quicsilver.logger.error("Message error: #{e.message} (0x#{e.error_code.to_s(16)})")
+        Quicsilver.stream_reset(stream.stream_handle, e.error_code) if stream.writable?
+      rescue => e
+        Quicsilver.logger.error("Error handling request: #{e.class} - #{e.message}")
+        Quicsilver.logger.debug(e.backtrace.first(5).join("\n"))
+        connection.send_error(stream, 500, "Internal Server Error") if stream.writable?
+      ensure
+        @request_registry.complete(stream.stream_id) if @request_registry.include?(stream.stream_id)
+        @cancelled_mutex.synchronize { @cancelled_streams.delete(stream.stream_id) }
+      end
+
+      private
+
+      def cancelled_stream?(stream_id)
+        @cancelled_mutex.synchronize { @cancelled_streams.include?(stream_id) }
+      end
+    end
+  end
+end

data/lib/quicsilver/server/request_registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    class RequestRegistry
+      def initialize
+        @requests = {}
+        @mutex = Mutex.new
+      end
+
+      def track(stream_id, connection_handle, path:, method:, started_at: Time.now)
+        @mutex.synchronize do
+          @requests[stream_id] = {
+            connection_handle: connection_handle,
+            path: path,
+            method: method,
+            started_at: started_at
+          }
+        end
+      end
+
+      def complete(stream_id)
+        @mutex.synchronize { @requests.delete(stream_id) }
+      end
+
+      def active_count
+        @mutex.synchronize { @requests.size }
+      end
+
+      def active_requests
+        @mutex.synchronize { @requests.dup }
+      end
+
+      def requests_older_than(seconds)
+        cutoff = Time.now - seconds
+        @mutex.synchronize do
+          @requests.select { |_, r| r[:started_at] < cutoff }
+        end
+      end
+
+      def empty?
+        @mutex.synchronize { @requests.empty? }
+      end
+
+      def include?(stream_id)
+        @mutex.synchronize { @requests.key?(stream_id) }
+      end
+    end
+  end
+end

data/lib/quicsilver/server/server.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    attr_reader :address, :port, :server_configuration, :running, :connections, :request_registry, :shutting_down, :max_queue_size, :max_connections
+
+    STREAM_EVENT_RECEIVE = "RECEIVE"
+    STREAM_EVENT_RECEIVE_FIN = "RECEIVE_FIN"
+    STREAM_EVENT_CONNECTION_ESTABLISHED = "CONNECTION_ESTABLISHED"
+    STREAM_EVENT_SEND_COMPLETE = "SEND_COMPLETE"
+    STREAM_EVENT_CONNECTION_CLOSED = "CONNECTION_CLOSED"
+    STREAM_EVENT_STREAM_RESET = "STREAM_RESET"
+    STREAM_EVENT_STOP_SENDING = "STOP_SENDING"
+
+    ServerStopError = Class.new(StandardError)
+    DrainTimeoutError = Class.new(StandardError)
+
+    class << self
+      attr_accessor :instance
+
+      # Callback from C extension - delegates to server instance
+      def handle_stream(connection_data, stream_id, event, data, early_data)
+        instance&.handle_stream_event(connection_data, stream_id, event, data, early_data)
+      end
+    end
+
+    DEFAULT_THREAD_POOL_SIZE = 5
+    DEFAULT_QUEUE_MULTIPLIER = 4
+    DEFAULT_MAX_CONNECTIONS = 100
+
+    def initialize(port = 4433, address: "0.0.0.0", app: nil, server_configuration: nil, threads: DEFAULT_THREAD_POOL_SIZE, max_queue_size: nil, max_connections: DEFAULT_MAX_CONNECTIONS)
+      @port = port
+      @address = address
+      @app = app || default_rack_app
+      @server_configuration = server_configuration || Transport::Configuration.new
+      @running = false
+      @shutting_down = false
+      @listener_data = nil
+      @config_handle = nil
+      @connections = {}
+      @request_registry = RequestRegistry.new
+      @handler_threads = []
+      @handler_mutex = Mutex.new
+      @thread_pool_size = threads
+      @max_queue_size = max_queue_size || threads * DEFAULT_QUEUE_MULTIPLIER
+      @work_queue = Queue.new
+      @max_connections = max_connections
+      @cancelled_streams = Set.new
+      @cancelled_mutex = Mutex.new
+
+      @request_handler = RequestHandler.new(
+        app: @app,
+        configuration: @server_configuration,
+        request_registry: @request_registry,
+        cancelled_streams: @cancelled_streams,
+        cancelled_mutex: @cancelled_mutex
+      )
+
+      self.class.instance = self
+    end
+
+    def start
+      raise ServerIsRunningError, "Server is already running" if @running
+
+      Quicsilver.open_connection
+      @config_handle = Quicsilver.create_server_configuration(@server_configuration.to_h)
+      raise ServerConfigurationError, "Failed to create server configuration" unless @config_handle
+
+      result = Quicsilver.create_listener(@config_handle)
+      @listener_data = ListenerData.new(result[0], result[1])
+      raise ServerListenerError, "Failed to create listener #{@address}:#{@port}"  unless @listener_data
+
+      unless Quicsilver.start_listener(@listener_data.listener_handle, @address, @port, @server_configuration.alpn)
+        Quicsilver.close_configuration(@config_handle)
+        @config_handle = nil
+        cleanup_failed_server
+        raise ServerListenerError, "Failed to start listener on #{@address}:#{@port}"
+      end
+
+      @running = true
+
+      setup_signal_handlers
+      start_worker_pool
+      Quicsilver.event_loop.start
+      Quicsilver.event_loop.join  # Block until shutdown
+    rescue ServerConfigurationError, ServerListenerError => e
+      cleanup_failed_server
+      @running = false
+      raise e
+    rescue => e
+      cleanup_failed_server
+      @running = false
+
+      error_msg = case e.message
+      when /0x16/
+        "Invalid parameter error - check certificate files and network configuration"
+      when /0x30/
+        "Address already in use - port #{@port} may be occupied"
+      else
+        e.message
+      end
+
+      raise ServerError, "Server start failed: #{error_msg}"
+    end
+
+    def stop
+      return unless @running
+
+      drain
+
+      if @listener_data && @listener_data.listener_handle
+        Quicsilver.stop_listener(@listener_data.listener_handle)
+        Quicsilver.close_listener([@listener_data.listener_handle, @listener_data.context_handle])
+      end
+
+      if @config_handle
+        Quicsilver.close_configuration(@config_handle)
+        @config_handle = nil
+      end
+
+      Quicsilver.event_loop.stop
+      @running = false
+      @listener_data = nil
+    rescue => e
+      @listener_data = nil
+      @running = false
+      raise ServerStopError, "Failed to stop server: #{e.message}"
+    end
+
+    def running?
+      @running
+    end
+
+    def cancelled_stream?(stream_id)
+      @cancelled_mutex.synchronize { @cancelled_streams.include?(stream_id) }
+    end
+
+    # Wait for work queue to drain, then shut down the pool
+    def drain(timeout: 5)
+      Quicsilver.logger.debug("Draining work queue (#{@work_queue.size} pending)")
+
+      deadline = Time.now + timeout
+
+      # Wait for work queue to empty
+      while @work_queue.size > 0 && Time.now < deadline
+        sleep 0.05
+      end
+
+      # Signal workers to exit
+      stop_worker_pool
+    end
+
+    # Graceful shutdown: send GOAWAY, drain requests, then stop
+    def shutdown(timeout: 30)
+      return unless @running
+      return if @shutting_down
+
+      @shutting_down = true
+      Quicsilver.logger.info("Initiating graceful shutdown (timeout: #{timeout}s)")
+
+      # Phase 1: Send GOAWAY - tell clients to stop sending new requests
+      @connections.each_value { |c| c.send_goaway(Protocol::MAX_STREAM_ID) }
+
+      # Phase 2: Drain in-flight requests
+      drain(timeout: timeout)
+
+      # Grace period: let pending responses reach clients
+      sleep 0.5
+
+      # Log any requests that didn't complete
+      unless @request_registry.empty?
+        @request_registry.active_requests.each do |stream_id, req|
+          elapsed = Time.now - req[:started_at]
+          Quicsilver.logger.warn("Force-closing request: #{req[:method]} #{req[:path]} (stream: #{stream_id}, elapsed: #{elapsed.round(2)}s)")
+        end
+      end
+
+      # Phase 3: Shutdown connections
+      @connections.each_value(&:shutdown)
+      sleep 0.1
+
+      # Phase 4: Hard stop
+      stop
+      @shutting_down = false
+
+      Quicsilver.logger.info("Graceful shutdown complete")
+    end
+
+    def handle_stream_event(connection_data, stream_id, event, data, early_data) # :nodoc:
+      connection_handle = connection_data[0]
+
+      case event
+      when STREAM_EVENT_CONNECTION_ESTABLISHED
+        if @connections.size >= @max_connections
+          Quicsilver.logger.warn("Connection limit reached (#{@max_connections}), rejecting connection")
+          Quicsilver.connection_shutdown(connection_handle, Protocol::H3_EXCESSIVE_LOAD, false)
+          return
+        end
+
+        connection = Transport::Connection.new(connection_handle, connection_data)
+        @connections[connection_handle] = connection
+        connection.setup_http3_streams
+
+      when STREAM_EVENT_CONNECTION_CLOSED
+        @connections.delete(connection_handle)&.streams&.clear
+        Quicsilver.close_server_connection(connection_handle)
+
+      when STREAM_EVENT_SEND_COMPLETE
+        # Buffer cleanup handled in C extension
+
+      when STREAM_EVENT_RECEIVE
+        return unless (connection = @connections[connection_handle])
+
+        # Unidirectional streams (control, QPACK) must be processed incrementally —
+        # they never send FIN, so waiting for RECEIVE_FIN would mean never parsing.
+        if (stream_id & 0x02) != 0  # unidirectional
+          begin
+            connection.receive_unidirectional_data(stream_id, data)
+          rescue Protocol::FrameError => e
+            Quicsilver.logger.error("Control stream error: #{e.message} (0x#{e.error_code.to_s(16)})")
+            Quicsilver.connection_shutdown(connection_handle, e.error_code, false) rescue nil
+          end
+        else
+          connection.buffer_data(stream_id, data)
+        end
+
+      when STREAM_EVENT_RECEIVE_FIN
+        return unless (connection = @connections[connection_handle])
+
+        event = Transport::StreamEvent.new(data, "RECEIVE_FIN")
+
+        full_data = connection.complete_stream(stream_id, event.data)
+        stream = Transport::InboundStream.new(stream_id)
+        stream.stream_handle = event.handle
+        stream.append_data(full_data)
+
+        if stream.bidirectional?
+          connection.track_client_stream(stream_id)
+          dispatch_request(connection, stream, early_data: early_data)
+        else
+          begin
+            connection.handle_unidirectional_stream(stream)
+          rescue Protocol::FrameError => e
+            Quicsilver.logger.error("Control stream error: #{e.message} (0x#{e.error_code.to_s(16)})")
+            Quicsilver.connection_shutdown(connection_handle, e.error_code, false) rescue nil
+          end
+        end
+
+      when STREAM_EVENT_STREAM_RESET
+        return unless (connection = @connections[connection_handle])
+        event = Transport::StreamEvent.new(data, "STREAM_RESET")
+        Quicsilver.logger.debug("Stream #{stream_id} reset by peer with error code: 0x#{event.error_code.to_s(16)}")
+
+        # Closing a critical unidirectional stream is a connection error (RFC 9114 §6.2.1)
+        if connection.critical_stream?(stream_id)
+          Quicsilver.logger.error("Critical stream #{stream_id} reset by peer")
+          Quicsilver.connection_shutdown(connection_handle, Protocol::H3_CLOSED_CRITICAL_STREAM, false) rescue nil
+        else
+          @cancelled_mutex.synchronize { @cancelled_streams.add(stream_id) }
+          @request_registry.complete(stream_id)
+        end
+
+      when STREAM_EVENT_STOP_SENDING
+        return unless @connections[connection_handle]
+        event = Transport::StreamEvent.new(data, "STOP_SENDING")
+        Quicsilver.logger.debug("Stream #{stream_id} stop sending requested with error code: 0x#{event.error_code.to_s(16)}")
+        @cancelled_mutex.synchronize { @cancelled_streams.add(stream_id) }
+        Quicsilver.stream_reset(event.handle, Protocol::H3_REQUEST_CANCELLED)
+        @request_registry.complete(stream_id)
+      end
+    end
+
+    private
+
+    def setup_signal_handlers
+      %w[INT TERM].each do |signal|
+        trap(signal) { Thread.new { shutdown } }
+      end
+    end
+
+    def default_rack_app
+      ->(env) {
+        [200,
+         {"Content-Type" => "text/plain"},
+         ["Hello from Quicsilver!\nMethod: #{env['REQUEST_METHOD']}\nPath: #{env['PATH_INFO']}\n"]]
+      }
+    end
+
+    def cleanup_failed_server
+      if @listener_data
+        begin
+          Quicsilver.stop_listener(@listener_data.listener_handle) if @listener_data.listener_handle
+          Quicsilver.close_listener([@listener_data.listener_handle, @listener_data.context_handle]) if @listener_data.listener_handle
+        rescue
+          # Ignore cleanup errors
+        ensure
+          @listener_data = nil
+        end
+      end
+    end
+
+    attr_reader :work_queue
+
+    def dispatch_request(connection, stream, early_data: false)
+      if @work_queue.size >= @max_queue_size
+        Quicsilver.logger.warn("Work queue full (#{@max_queue_size}), rejecting request")
+        connection.send_error(stream, 503, "Service Unavailable") if stream.writable?
+      else
+        @work_queue.push([connection, stream, early_data])
+      end
+    end
+
+    def start_worker_pool
+      @thread_pool_size.times do
+        thread = Thread.new do
+          while (work = @work_queue.pop)
+            break if work == :shutdown
+            connection, stream, early_data = work
+            @request_handler.call(connection, stream, early_data: early_data)
+          end
+        end
+        @handler_mutex.synchronize { @handler_threads << thread }
+      end
+    end
+
+    def stop_worker_pool
+      @thread_pool_size.times { @work_queue.push(:shutdown) }
+      @handler_mutex.synchronize do
+        @handler_threads.each { |t| t.join(2) }
+        # Raise into any stuck workers
+        @handler_threads.each { |t| t.raise(DrainTimeoutError, "drain timeout") if t.alive? }
+        @handler_threads.clear
+      end
+    end
+  end
+end

data/lib/quicsilver/transport/configuration.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Transport
+    class Configuration
+      attr_reader :cert_file, :key_file, :idle_timeout_ms, :server_resumption_level, :max_concurrent_requests,
+        :max_unidirectional_streams, :stream_receive_window, :stream_receive_buffer, :connection_flow_control_window,
+        :pacing_enabled, :send_buffering_enabled, :initial_rtt_ms, :initial_window_packets, :max_ack_delay_ms,
+        :keep_alive_interval_ms, :congestion_control_algorithm, :migration_enabled,
+        :disconnect_timeout_ms, :handshake_idle_timeout_ms,
+        :max_body_size, :max_header_size, :max_header_count, :max_frame_payload_size,
+        :early_data_policy
+
+      QUIC_SERVER_RESUME_AND_ZERORTT = 1
+      QUIC_SERVER_RESUME_ONLY = 2
+      QUIC_SERVER_RESUME_AND_REUSE = 3
+      QUIC_SERVER_RESUME_AND_REUSE_ZERORTT = 4
+
+      # Congestion control algorithms
+      CONGESTION_CONTROL_CUBIC = 0
+      CONGESTION_CONTROL_BBR = 1
+
+      DEFAULT_CERT_FILE = "certificates/server.crt"
+      DEFAULT_KEY_FILE = "certificates/server.key"
+      DEFAULT_ALPN = "h3"
+
+      # Flow control defaults — cross-referenced with quiche, quic-go, lsquic, RFC 9000
+      # See: https://github.com/microsoft/msquic/blob/main/docs/Settings.md
+      DEFAULT_STREAM_RECEIVE_WINDOW = 262_144       # 256KB (quiche/quic-go use 1MB, MsQuic default 64KB)
+      DEFAULT_STREAM_RECEIVE_BUFFER = 32_768        # 32KB (MsQuic default 4KB — too small for typical responses)
+      DEFAULT_CONNECTION_FLOW_CONTROL_WINDOW = 16_777_216  # 16MB - connection-wide flow control
+
+      # Throughput defaults
+      DEFAULT_PACING_ENABLED = true              # RFC 9002: MUST pace or limit bursts
+      DEFAULT_SEND_BUFFERING_ENABLED = true      # MsQuic recommended — coalesces small writes
+      DEFAULT_INITIAL_RTT_MS = 100               # MsQuic default 333ms is satellite-grade; 100ms matches Chromium
+      DEFAULT_INITIAL_WINDOW_PACKETS = 10        # Matches RFC 9002 recommendation
+      DEFAULT_MAX_ACK_DELAY_MS = 25              # Matches RFC 9000 default
+
+      # Connection management defaults
+      DEFAULT_KEEP_ALIVE_INTERVAL_MS = 0         # 0 = disabled. Set to 20000 for NAT traversal
+      DEFAULT_CONGESTION_CONTROL_ALGORITHM = CONGESTION_CONTROL_CUBIC  # CUBIC (0) or BBR (1)
+      DEFAULT_MIGRATION_ENABLED = true           # Client IP migration. Disable behind load balancers
+      DEFAULT_DISCONNECT_TIMEOUT_MS = 16_000     # How long to wait for ACK before path declared dead
+      DEFAULT_HANDSHAKE_IDLE_TIMEOUT_MS = 10_000 # Handshake timeout (separate from connection idle)
+
+      def initialize(cert_file = nil, key_file = nil, options = {})
+        @idle_timeout_ms = options.fetch(:idle_timeout_ms, 10000)
+        @server_resumption_level = options.fetch(:server_resumption_level, QUIC_SERVER_RESUME_AND_ZERORTT)
+        @max_concurrent_requests = options.fetch(:max_concurrent_requests, 100)
+        @max_unidirectional_streams = options.fetch(:max_unidirectional_streams, 10)
+        @alpn = options.fetch(:alpn, DEFAULT_ALPN)
+
+        # Flow control
+        @stream_receive_window = options.fetch(:stream_receive_window, DEFAULT_STREAM_RECEIVE_WINDOW)
+        @stream_receive_buffer = options.fetch(:stream_receive_buffer, DEFAULT_STREAM_RECEIVE_BUFFER)
+        @connection_flow_control_window = options.fetch(:connection_flow_control_window, DEFAULT_CONNECTION_FLOW_CONTROL_WINDOW)
+
+        # Throughput
+        @pacing_enabled = options.fetch(:pacing_enabled, DEFAULT_PACING_ENABLED)
+        @send_buffering_enabled = options.fetch(:send_buffering_enabled, DEFAULT_SEND_BUFFERING_ENABLED)
+        @initial_rtt_ms = options.fetch(:initial_rtt_ms, DEFAULT_INITIAL_RTT_MS)
+        @initial_window_packets = options.fetch(:initial_window_packets, DEFAULT_INITIAL_WINDOW_PACKETS)
+        @max_ack_delay_ms = options.fetch(:max_ack_delay_ms, DEFAULT_MAX_ACK_DELAY_MS)
+
+        # Connection management
+        @keep_alive_interval_ms = options.fetch(:keep_alive_interval_ms, DEFAULT_KEEP_ALIVE_INTERVAL_MS)
+        @congestion_control_algorithm = options.fetch(:congestion_control_algorithm, DEFAULT_CONGESTION_CONTROL_ALGORITHM)
+        @migration_enabled = options.fetch(:migration_enabled, DEFAULT_MIGRATION_ENABLED)
+        @disconnect_timeout_ms = options.fetch(:disconnect_timeout_ms, DEFAULT_DISCONNECT_TIMEOUT_MS)
+        @handshake_idle_timeout_ms = options.fetch(:handshake_idle_timeout_ms, DEFAULT_HANDSHAKE_IDLE_TIMEOUT_MS)
+
+        # HTTP/3 parser limits (nil = unlimited)
+        @max_body_size = options[:max_body_size]
+        @max_header_size = options[:max_header_size]
+        @max_header_count = options[:max_header_count]
+        @max_frame_payload_size = options[:max_frame_payload_size]
+
+        # 0-RTT early data policy (RFC 8470)
+        # :reject (default) — send 425 Too Early for unsafe methods on 0-RTT
+        # :allow — pass all 0-RTT requests to the Rack app with env["quicsilver.early_data"]
+        @early_data_policy = options.fetch(:early_data_policy, :reject)
+        unless %i[reject allow].include?(@early_data_policy)
+          raise ServerConfigurationError, "Invalid early_data_policy: #{@early_data_policy.inspect} (must be :reject or :allow)"
+        end
+
+        @cert_file = cert_file.nil? ? DEFAULT_CERT_FILE : cert_file
+        @key_file = key_file.nil? ? DEFAULT_KEY_FILE : key_file
+
+        unless File.exist?(@cert_file)
+          raise ServerConfigurationError, "Certificate file not found: #{@cert_file}"
+        end
+
+        unless File.exist?(@key_file)
+          raise ServerConfigurationError, "Key file not found: #{@key_file}"
+        end
+      end
+
+      # Common HTTP/3 ALPN Values:
+      # "h3" - HTTP/3 (most common)
+      # "h3-29" - HTTP/3 draft version 29
+      def alpn
+        @alpn
+      end
+
+      def to_h
+        {
+          cert_file: @cert_file,
+          key_file: @key_file,
+          idle_timeout_ms: @idle_timeout_ms,
+          server_resumption_level: @server_resumption_level,
+          max_concurrent_requests: @max_concurrent_requests,
+          max_unidirectional_streams: @max_unidirectional_streams,
+          alpn: alpn,
+          stream_receive_window: @stream_receive_window,
+          stream_receive_buffer: @stream_receive_buffer,
+          connection_flow_control_window: @connection_flow_control_window,
+          pacing_enabled: @pacing_enabled ? 1 : 0,
+          send_buffering_enabled: @send_buffering_enabled ? 1 : 0,
+          initial_rtt_ms: @initial_rtt_ms,
+          initial_window_packets: @initial_window_packets,
+          max_ack_delay_ms: @max_ack_delay_ms,
+          keep_alive_interval_ms: @keep_alive_interval_ms,
+          congestion_control_algorithm: @congestion_control_algorithm,
+          migration_enabled: @migration_enabled ? 1 : 0,
+          disconnect_timeout_ms: @disconnect_timeout_ms,
+          handshake_idle_timeout_ms: @handshake_idle_timeout_ms
+        }
+      end
+    end
+  end
+end