nghttp3 0.0.1

data/ext/nghttp3/nghttp3_settings.c

@@ -0,0 +1,188 @@
+#include "nghttp3.h"
+
+VALUE rb_cNghttp3Settings;
+
+typedef struct {
+  nghttp3_settings settings;
+} SettingsObj;
+
+static void settings_free(void *ptr) { xfree(ptr); }
+
+static size_t settings_memsize(const void *ptr) { return sizeof(SettingsObj); }
+
+const rb_data_type_t settings_data_type = {
+    .wrap_struct_name = "nghttp3_settings_rb",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = settings_free,
+            .dsize = settings_memsize,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE settings_alloc(VALUE klass) {
+  SettingsObj *obj;
+  VALUE self =
+      TypedData_Make_Struct(klass, SettingsObj, &settings_data_type, obj);
+  memset(&obj->settings, 0, sizeof(nghttp3_settings));
+  return self;
+}
+
+/*
+ * Returns a pointer to the underlying nghttp3_settings structure.
+ */
+nghttp3_settings *nghttp3_rb_get_settings(VALUE rb_settings) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(rb_settings, SettingsObj, &settings_data_type, obj);
+  return &obj->settings;
+}
+
+/*
+ * call-seq:
+ *   Settings.new -> Settings
+ *
+ * Creates a new Settings object with all values set to zero.
+ */
+static VALUE rb_nghttp3_settings_initialize(VALUE self) { return self; }
+
+/*
+ * call-seq:
+ *   Settings.default -> Settings
+ *
+ * Creates a new Settings object with default values from nghttp3.
+ */
+static VALUE rb_nghttp3_settings_default(VALUE klass) {
+  VALUE self = settings_alloc(klass);
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  nghttp3_settings_default(&obj->settings);
+  return self;
+}
+
+/* Settings getters */
+static VALUE rb_nghttp3_settings_get_max_field_section_size(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return ULL2NUM(obj->settings.max_field_section_size);
+}
+
+static VALUE rb_nghttp3_settings_get_qpack_max_dtable_capacity(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return SIZET2NUM(obj->settings.qpack_max_dtable_capacity);
+}
+
+static VALUE
+rb_nghttp3_settings_get_qpack_encoder_max_dtable_capacity(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return SIZET2NUM(obj->settings.qpack_encoder_max_dtable_capacity);
+}
+
+static VALUE rb_nghttp3_settings_get_qpack_blocked_streams(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return SIZET2NUM(obj->settings.qpack_blocked_streams);
+}
+
+static VALUE rb_nghttp3_settings_get_enable_connect_protocol(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return obj->settings.enable_connect_protocol ? Qtrue : Qfalse;
+}
+
+static VALUE rb_nghttp3_settings_get_h3_datagram(VALUE self) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  return obj->settings.h3_datagram ? Qtrue : Qfalse;
+}
+
+/* Settings setters */
+static VALUE rb_nghttp3_settings_set_max_field_section_size(VALUE self,
+                                                            VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.max_field_section_size = NUM2ULL(val);
+  return val;
+}
+
+static VALUE rb_nghttp3_settings_set_qpack_max_dtable_capacity(VALUE self,
+                                                               VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.qpack_max_dtable_capacity = NUM2SIZET(val);
+  return val;
+}
+
+static VALUE
+rb_nghttp3_settings_set_qpack_encoder_max_dtable_capacity(VALUE self,
+                                                          VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.qpack_encoder_max_dtable_capacity = NUM2SIZET(val);
+  return val;
+}
+
+static VALUE rb_nghttp3_settings_set_qpack_blocked_streams(VALUE self,
+                                                           VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.qpack_blocked_streams = NUM2SIZET(val);
+  return val;
+}
+
+static VALUE rb_nghttp3_settings_set_enable_connect_protocol(VALUE self,
+                                                             VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.enable_connect_protocol = RTEST(val) ? 1 : 0;
+  return val;
+}
+
+static VALUE rb_nghttp3_settings_set_h3_datagram(VALUE self, VALUE val) {
+  SettingsObj *obj;
+  TypedData_Get_Struct(self, SettingsObj, &settings_data_type, obj);
+  obj->settings.h3_datagram = RTEST(val) ? 1 : 0;
+  return val;
+}
+
+void Init_nghttp3_settings(void) {
+  rb_cNghttp3Settings =
+      rb_define_class_under(rb_mNghttp3, "Settings", rb_cObject);
+  rb_define_alloc_func(rb_cNghttp3Settings, settings_alloc);
+  rb_define_method(rb_cNghttp3Settings, "initialize",
+                   rb_nghttp3_settings_initialize, 0);
+  rb_define_singleton_method(rb_cNghttp3Settings, "default",
+                             rb_nghttp3_settings_default, 0);
+
+  /* Settings getters */
+  rb_define_method(rb_cNghttp3Settings, "max_field_section_size",
+                   rb_nghttp3_settings_get_max_field_section_size, 0);
+  rb_define_method(rb_cNghttp3Settings, "qpack_max_dtable_capacity",
+                   rb_nghttp3_settings_get_qpack_max_dtable_capacity, 0);
+  rb_define_method(rb_cNghttp3Settings, "qpack_encoder_max_dtable_capacity",
+                   rb_nghttp3_settings_get_qpack_encoder_max_dtable_capacity,
+                   0);
+  rb_define_method(rb_cNghttp3Settings, "qpack_blocked_streams",
+                   rb_nghttp3_settings_get_qpack_blocked_streams, 0);
+  rb_define_method(rb_cNghttp3Settings, "enable_connect_protocol",
+                   rb_nghttp3_settings_get_enable_connect_protocol, 0);
+  rb_define_method(rb_cNghttp3Settings, "h3_datagram",
+                   rb_nghttp3_settings_get_h3_datagram, 0);
+
+  /* Settings setters */
+  rb_define_method(rb_cNghttp3Settings, "max_field_section_size=",
+                   rb_nghttp3_settings_set_max_field_section_size, 1);
+  rb_define_method(rb_cNghttp3Settings, "qpack_max_dtable_capacity=",
+                   rb_nghttp3_settings_set_qpack_max_dtable_capacity, 1);
+  rb_define_method(rb_cNghttp3Settings, "qpack_encoder_max_dtable_capacity=",
+                   rb_nghttp3_settings_set_qpack_encoder_max_dtable_capacity,
+                   1);
+  rb_define_method(rb_cNghttp3Settings, "qpack_blocked_streams=",
+                   rb_nghttp3_settings_set_qpack_blocked_streams, 1);
+  rb_define_method(rb_cNghttp3Settings, "enable_connect_protocol=",
+                   rb_nghttp3_settings_set_enable_connect_protocol, 1);
+  rb_define_method(rb_cNghttp3Settings,
+                   "h3_datagram=", rb_nghttp3_settings_set_h3_datagram, 1);
+}

data/lib/nghttp3/client.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Nghttp3
+  # High-level HTTP/3 client
+  #
+  # Wraps the low-level Connection API with automatic stream management,
+  # convenient request methods, and response tracking.
+  #
+  # @example Basic usage
+  #   client = Nghttp3::Client.new
+  #   client.bind_streams(control: 2, qpack_encoder: 6, qpack_decoder: 10)
+  #
+  #   stream_id = client.get("https://example.com/path")
+  #
+  #   # Pump data to QUIC layer
+  #   client.pump_writes do |stream_id, data, fin|
+  #     quic.write(stream_id, data, fin)
+  #   end
+  #
+  #   # Feed data from QUIC layer
+  #   client.read_stream(stream_id, received_data, fin: false)
+  #
+  #   # Get response when ready
+  #   response = client.responses[stream_id]
+  class Client
+    # @return [Connection] the underlying low-level connection
+    attr_reader :connection
+
+    # @return [Settings] the settings used for this client
+    attr_reader :settings
+
+    # @return [Hash{Integer => Response}] responses by stream ID
+    attr_reader :responses
+
+    # @return [Hash{Integer => Request}] pending requests by stream ID
+    attr_reader :pending_requests
+
+    # Create a new HTTP/3 client
+    # @param settings [Settings, nil] settings to use (defaults to Settings.default)
+    def initialize(settings: nil)
+      @settings = settings || Settings.default
+      @callbacks = setup_callbacks
+      @connection = Connection.client_new(@settings, @callbacks)
+      @stream_manager = StreamManager.new(is_server: false)
+      @pending_requests = {}
+      @responses = {}
+      @streams_bound = false
+    end
+
+    # Bind control and QPACK streams
+    #
+    # Must be called before submitting requests. The stream IDs should be
+    # unidirectional streams opened by the QUIC layer.
+    #
+    # @param control [Integer] control stream ID
+    # @param qpack_encoder [Integer] QPACK encoder stream ID
+    # @param qpack_decoder [Integer] QPACK decoder stream ID
+    # @return [self]
+    def bind_streams(control:, qpack_encoder:, qpack_decoder:)
+      @connection.bind_control_stream(control)
+      @connection.bind_qpack_streams(qpack_encoder, qpack_decoder)
+      @stream_manager.register_stream(control, type: :uni)
+      @stream_manager.register_stream(qpack_encoder, type: :uni)
+      @stream_manager.register_stream(qpack_decoder, type: :uni)
+      @streams_bound = true
+      self
+    end
+
+    # Check if streams are bound
+    # @return [Boolean]
+    def streams_bound?
+      @streams_bound
+    end
+
+    # Submit a request
+    # @param request [Request] the request to submit
+    # @return [Integer] the stream ID for this request
+    def submit(request)
+      raise InvalidStateError, "Streams not bound. Call bind_streams first." unless @streams_bound
+
+      stream_id = @stream_manager.allocate_bidi_stream_id
+      @pending_requests[stream_id] = request
+      @responses[stream_id] = Response.new(stream_id: stream_id)
+
+      @connection.submit_request(stream_id, request.to_nv_array, body: request.body)
+      stream_id
+    end
+
+    # Convenience method for GET request
+    # @param url [String] URL to request
+    # @param headers [Hash] additional headers
+    # @return [Integer] stream ID
+    def get(url, headers: {})
+      submit(Request.get(url, headers: headers))
+    end
+
+    # Convenience method for POST request
+    # @param url [String] URL to request
+    # @param body [String, nil] request body
+    # @param headers [Hash] additional headers
+    # @return [Integer] stream ID
+    def post(url, body: nil, headers: {})
+      submit(Request.post(url, body: body, headers: headers))
+    end
+
+    # Convenience method for PUT request
+    # @param url [String] URL to request
+    # @param body [String, nil] request body
+    # @param headers [Hash] additional headers
+    # @return [Integer] stream ID
+    def put(url, body: nil, headers: {})
+      submit(Request.put(url, body: body, headers: headers))
+    end
+
+    # Convenience method for DELETE request
+    # @param url [String] URL to request
+    # @param headers [Hash] additional headers
+    # @return [Integer] stream ID
+    def delete(url, headers: {})
+      submit(Request.delete(url, headers: headers))
+    end
+
+    # Convenience method for HEAD request
+    # @param url [String] URL to request
+    # @param headers [Hash] additional headers
+    # @return [Integer] stream ID
+    def head(url, headers: {})
+      submit(Request.head(url, headers: headers))
+    end
+
+    # Pump pending writes to the QUIC layer
+    #
+    # @yield [stream_id, data, fin] for each pending write
+    # @yieldparam stream_id [Integer] the stream ID
+    # @yieldparam data [String] the data to write
+    # @yieldparam fin [Boolean] true if this is the final data for the stream
+    # @yieldreturn [Integer] number of bytes accepted by QUIC layer
+    # @return [self]
+    def pump_writes
+      while (result = @connection.writev_stream)
+        stream_id = result[:stream_id]
+        data = result[:data]
+        fin = result[:fin]
+
+        bytes_written = yield(stream_id, data, fin) if block_given?
+        bytes_written ||= data.bytesize
+
+        @connection.add_write_offset(stream_id, bytes_written)
+      end
+      self
+    end
+
+    # Read data from QUIC layer into HTTP/3 connection
+    # @param stream_id [Integer] stream ID
+    # @param data [String] received data
+    # @param fin [Boolean] true if this is the final data for the stream
+    # @return [Integer] number of bytes consumed
+    def read_stream(stream_id, data, fin: false)
+      @connection.read_stream(stream_id, data, fin: fin)
+    end
+
+    # Notify that bytes have been acknowledged by the peer
+    # @param stream_id [Integer] stream ID
+    # @param n [Integer] number of bytes acknowledged
+    # @return [self]
+    def add_ack_offset(stream_id, n)
+      @connection.add_ack_offset(stream_id, n)
+      self
+    end
+
+    # Close the client connection
+    # @return [nil]
+    def close
+      @connection.close
+    end
+
+    # Check if the connection is closed
+    # @return [Boolean]
+    def closed?
+      @connection.closed?
+    end
+
+    private
+
+    def setup_callbacks
+      Callbacks.new
+        .on_begin_headers { |stream_id| on_begin_headers(stream_id) }
+        .on_recv_header { |stream_id, name, value, flags| on_recv_header(stream_id, name, value, flags) }
+        .on_end_headers { |stream_id, fin| on_end_headers(stream_id, fin) }
+        .on_recv_data { |stream_id, data| on_recv_data(stream_id, data) }
+        .on_end_stream { |stream_id| on_end_stream(stream_id) }
+        .on_stream_close { |stream_id, app_error_code| on_stream_close(stream_id, app_error_code) }
+    end
+
+    def on_begin_headers(stream_id)
+      # Response headers starting
+      @responses[stream_id] ||= Response.new(stream_id: stream_id)
+    end
+
+    def on_recv_header(stream_id, name, value, _flags)
+      response = @responses[stream_id]
+      return unless response
+
+      if name == ":status"
+        response.status = value.to_i
+      else
+        response.headers[name] = value
+      end
+    end
+
+    def on_end_headers(stream_id, _fin)
+      # Headers complete
+      response = @responses[stream_id]
+      response&.write_headers
+    end
+
+    def on_recv_data(stream_id, data)
+      response = @responses[stream_id]
+      response&.append_body(data)
+    end
+
+    def on_end_stream(stream_id)
+      response = @responses[stream_id]
+      response&.finish
+      @pending_requests.delete(stream_id)
+      @stream_manager.close_stream(stream_id)
+    end
+
+    def on_stream_close(stream_id, _app_error_code)
+      response = @responses[stream_id]
+      response&.finish
+      @pending_requests.delete(stream_id)
+      @stream_manager.close_stream(stream_id)
+    end
+  end
+end

data/lib/nghttp3/headers.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Nghttp3
+  # A case-insensitive header collection for HTTP/3
+  #
+  # Header names are automatically normalized to lowercase.
+  # Supports multiple values for the same header name.
+  class Headers
+    include Enumerable
+
+    def initialize(hash = {})
+      @headers = {}
+      hash&.each { |k, v| self[k] = v }
+    end
+
+    # Get header value by name (case-insensitive)
+    # @param name [String, Symbol] header name
+    # @return [String, nil] header value or nil if not found
+    def [](name)
+      @headers[normalize_name(name)]
+    end
+
+    # Set header value (case-insensitive)
+    # @param name [String, Symbol] header name
+    # @param value [String, #to_s] header value
+    # @return [String] the value
+    def []=(name, value)
+      @headers[normalize_name(name)] = value.to_s
+    end
+
+    # Delete a header
+    # @param name [String, Symbol] header name
+    # @return [String, nil] deleted value or nil
+    def delete(name)
+      @headers.delete(normalize_name(name))
+    end
+
+    # Check if header exists
+    # @param name [String, Symbol] header name
+    # @return [Boolean]
+    def key?(name)
+      @headers.key?(normalize_name(name))
+    end
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+
+    # Iterate over all headers
+    # @yield [name, value] each header name-value pair
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      @headers.each(&block)
+    end
+
+    # Merge another hash into this headers collection
+    # @param other [Hash, Headers] headers to merge
+    # @return [self]
+    def merge!(other)
+      other.each { |k, v| self[k] = v }
+      self
+    end
+
+    # Return a new Headers with merged values
+    # @param other [Hash, Headers] headers to merge
+    # @return [Headers] new Headers instance
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    # Convert to Hash
+    # @return [Hash{String => String}]
+    def to_h
+      @headers.dup
+    end
+    alias_method :to_hash, :to_h
+
+    # Number of headers
+    # @return [Integer]
+    def size
+      @headers.size
+    end
+    alias_method :length, :size
+
+    # Check if empty
+    # @return [Boolean]
+    def empty?
+      @headers.empty?
+    end
+
+    # Remove all headers
+    # @return [self]
+    def clear
+      @headers.clear
+      self
+    end
+
+    # Duplicate the headers collection
+    # @return [Headers]
+    def dup
+      self.class.new(@headers)
+    end
+
+    # String representation
+    def inspect
+      "#<#{self.class} #{@headers.inspect}>"
+    end
+
+    private
+
+    def normalize_name(name)
+      name.to_s.downcase
+    end
+  end
+end

data/lib/nghttp3/request.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Nghttp3
+  # An immutable HTTP/3 request object
+  #
+  # Represents an HTTP request with method, path, headers, and optional body.
+  # Can be created directly or via convenience factory methods.
+  class Request
+    # @return [String] HTTP method (GET, POST, etc.)
+    attr_reader :method
+
+    # @return [String] URL scheme (https, http)
+    attr_reader :scheme
+
+    # @return [String, nil] authority (host:port)
+    attr_reader :authority
+
+    # @return [String] request path
+    attr_reader :path
+
+    # @return [Headers] request headers
+    attr_reader :headers
+
+    # @return [String, nil] request body
+    attr_reader :body
+
+    # Create a new request
+    # @param method [String, Symbol] HTTP method
+    # @param path [String] request path
+    # @param scheme [String] URL scheme (default: "https")
+    # @param authority [String, nil] authority (host:port)
+    # @param headers [Hash, Headers] additional headers
+    # @param body [String, nil] request body
+    def initialize(method:, path:, scheme: "https", authority: nil, headers: {}, body: nil)
+      @method = method.to_s.upcase.freeze
+      @scheme = scheme.to_s.freeze
+      @authority = authority&.to_s&.freeze
+      @path = path.to_s.freeze
+      @headers = headers.is_a?(Headers) ? headers : Headers.new(headers)
+      @body = body&.dup&.freeze
+      freeze
+    end
+
+    # Convert to NV array for low-level Connection API
+    # @return [Array<NV>] array of NV objects for pseudo-headers and headers
+    def to_nv_array
+      nvs = []
+      nvs << NV.new(":method", @method)
+      nvs << NV.new(":scheme", @scheme)
+      nvs << NV.new(":authority", @authority) if @authority
+      nvs << NV.new(":path", @path)
+      @headers.each { |name, value| nvs << NV.new(name, value) }
+      nvs
+    end
+
+    # Check if request has a body
+    # @return [Boolean]
+    def body?
+      !@body.nil? && !@body.empty?
+    end
+
+    # String representation
+    def inspect
+      "#<#{self.class} #{@method} #{@scheme}://#{@authority}#{@path}>"
+    end
+
+    class << self
+      # Create a GET request
+      # @param url [String] full URL
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def get(url, headers: {})
+        build_from_url("GET", url, headers: headers)
+      end
+
+      # Create a POST request
+      # @param url [String] full URL
+      # @param body [String, nil] request body
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def post(url, body: nil, headers: {})
+        build_from_url("POST", url, body: body, headers: headers)
+      end
+
+      # Create a PUT request
+      # @param url [String] full URL
+      # @param body [String, nil] request body
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def put(url, body: nil, headers: {})
+        build_from_url("PUT", url, body: body, headers: headers)
+      end
+
+      # Create a DELETE request
+      # @param url [String] full URL
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def delete(url, headers: {})
+        build_from_url("DELETE", url, headers: headers)
+      end
+
+      # Create a HEAD request
+      # @param url [String] full URL
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def head(url, headers: {})
+        build_from_url("HEAD", url, headers: headers)
+      end
+
+      # Create a PATCH request
+      # @param url [String] full URL
+      # @param body [String, nil] request body
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def patch(url, body: nil, headers: {})
+        build_from_url("PATCH", url, body: body, headers: headers)
+      end
+
+      # Create an OPTIONS request
+      # @param url [String] full URL
+      # @param headers [Hash] additional headers
+      # @return [Request]
+      def options(url, headers: {})
+        build_from_url("OPTIONS", url, headers: headers)
+      end
+
+      private
+
+      def build_from_url(method, url, body: nil, headers: {})
+        uri = URI.parse(url)
+        authority = (uri.port == uri.default_port) ? uri.host : "#{uri.host}:#{uri.port}"
+        path = uri.request_uri.empty? ? "/" : uri.request_uri
+
+        new(
+          method: method,
+          scheme: uri.scheme || "https",
+          authority: authority,
+          path: path,
+          headers: headers,
+          body: body
+        )
+      end
+    end
+  end
+end