quic 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e019da100b72501ae5f3f097aa00344e763de5483e301b03e619c695e7ed269d
-  data.tar.gz: 922faa6c8b6b96e121849d4f17823e31cbfdeb05da3d93681603c3fb55840127
+  metadata.gz: fd02d782aebbc1128a0fca8bda34bc2651b5d677e682d126ab0575b332b4f556
+  data.tar.gz: 9a5155a1b4f75a342d7476895641e5b2e06a6f7d5e99b4bd6f1830c90e747cda
 SHA512:
-  metadata.gz: c1eb1754a7e98f652825f641d0a1bfb2c131d54fcaceffe2867b8000107752d39c7fcc9e739125085c84bb76272306213e5774730e408b4d6cfc2bb6ce61b5c9
-  data.tar.gz: 365881fb77b46679c549f6e19dc5988cd94f62a3ab13ee937e0514d12202a45a63c17501c6bf492b6363b2b33c81894651965f74425e44af37cc2e24f37c0aa5
+  metadata.gz: f94809c98904f20281edbc702f57db0c0014e53243fb2d478e02c1c54870fb205bad185aadf3ab319d4f2294484aca46cf58b72f4d5a486138584426cd513808
+  data.tar.gz: d1f7925f594bc307201a295aed815084000da0e0c2a057dc6ad403d587888b42ae4a478a5d4949603a5d5d70f3c51b9cc2fa1224d1783956c9b2330743e2e467

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.0.6] - 2026-11-03
+
+### Added
+- `quic/ext.h` is ABI 1.1: a stream handler's new `recv_stop_sending` is called as soon as the peer's STOP_SENDING arrives, instead of the handler learning of it when the stream closes. Handlers built for ABI 1.0 keep working. ([#23](https://github.com/unasuke/quic-ruby/pull/23))
+
+### Changed
+- ngtcp2 is now built from 1.26.0 (was 1.25.0), and picotls from `a2d95de`, the revision ngtcp2 1.26.0 is tested against. ([#24](https://github.com/unasuke/quic-ruby/pull/24))
+
+## [0.0.5] - 2026-10-24
+
+### Fixed
+- When the peer sends STOP_SENDING on a stream, what was queued on it but not yet sent is dropped, and `QUIC::Stream#write` and `#write_nonblock` raise `QUIC::Error::StreamClosed` carrying the STOP_SENDING's error code, a `#write` waiting for the peer's window included. Before, every `#write_pkt` after it raised `QUIC::Error::StreamClosed` while the stream had bytes left to send, and a waiting `#write` returned only at the idle timeout. ([#21](https://github.com/unasuke/quic-ruby/pull/21))
+- `#write_pkt` no longer raises `QUIC::Error::StreamClosed` after `QUIC::Stream#reset` on a stream with bytes queued; those bytes are dropped. ([#21](https://github.com/unasuke/quic-ruby/pull/21))
+
 ## [0.0.4] - 2026-10-22
 
 ### Added

data/LICENSE-DEPENDENCIES.txt

@@ -9,7 +9,7 @@ bundled nor redistributed. The quic gem itself is MIT licensed; see
 LICENSE.txt.
 
 
-ngtcp2 1.25.0 -- https://github.com/ngtcp2/ngtcp2
+ngtcp2 1.26.0 -- https://github.com/ngtcp2/ngtcp2
 -------------------------------------------------
 
 The MIT License
@@ -53,7 +53,7 @@ the statically linked libngtcp2 and are covered by their own terms:
     COPYING text above.
 
 
-picotls f07f1c8 -- https://github.com/h2o/picotls
+picotls a2d95de -- https://github.com/h2o/picotls
 -------------------------------------------------
 
 picotls has no top-level license file; the terms are stated in the header of

data/README.md

@@ -147,7 +147,7 @@ It applies to clients, `Connection::Server.accept` and every connection of an En
 
 ### From other native extensions
 
-Another native extension can drive a connection's streams from C instead of through `QUIC::Stream`, as the [http3](https://github.com/unasuke/http3-ruby) gem does. `quic/ext.h` declares the function table (ABI 1.0), and `QUIC::EXT_INCLUDE_DIR` tells an `extconf.rb` where it is:
+Another native extension can drive a connection's streams from C instead of through `QUIC::Stream`, as the [http3](https://github.com/unasuke/http3-ruby) gem does. `quic/ext.h` declares the function table (ABI 1.1; a stream handler built against ABI 1.0 keeps working), and `QUIC::EXT_INCLUDE_DIR` tells an `extconf.rb` where it is:
 
 ```ruby
 require "mkmf"

data/ext/quic/connection_common.c

@@ -508,7 +508,9 @@ static VALUE quic_acked_stream_data_offset_body(VALUE arg) {
   /* Shift any head Chunks of @pending_chunks whose end-offset is fully
      covered by acked_offset. Each Chunk's start-offset in the stream is
      pending_shifted (after previous shifts); its end-offset is
-     pending_shifted + RSTRING_LEN(head). */
+     pending_shifted + RSTRING_LEN(head). A stopped stream's
+     @pending_chunks is empty, and acks for what it sent before shift
+     nothing. */
   VALUE pending = rb_ivar_get(stream, rb_intern("@pending_chunks"));
   while (RARRAY_LEN(pending) > 0) {
     VALUE head = RARRAY_AREF(pending, 0);
@@ -626,9 +628,59 @@ static int quic_stream_reset_cb(ngtcp2_conn *conn, int64_t stream_id,
   return quic_conn_protect(c, quic_stream_reset_body, &a);
 }
 
+/* Nothing queued on stream can go out any more: drop it all, and have
+   #write_pkt skip the stream from now on. ngtcp2 retransmits no STREAM
+   frame of a stream it has reset, so it no longer reads the bytes it was
+   given either. */
+static void quic_stream_stop(VALUE stream) {
+  quic_stream_t *s;
+  TypedData_Get_Struct(stream, quic_stream_t, &quic_stream_data_type, s);
+  s->stopped = true;
+  rb_ary_clear(rb_ivar_get(stream, rb_intern("@pending_chunks")));
+}
+
+static VALUE quic_recv_stop_sending_body(VALUE arg) {
+  struct quic_stream_cb_args *a = (struct quic_stream_cb_args *)arg;
+  VALUE stream = quic_conn_lookup_stream(a->c, a->stream_id);
+  if (NIL_P(stream))
+    return Qnil;
+
+  quic_stream_t *s;
+  TypedData_Get_Struct(stream, quic_stream_t, &quic_stream_data_type, s);
+  s->stop_app_error_code = a->app_error_code;
+  quic_stream_stop(stream);
+  return Qnil;
+}
+
+/* The peer sent STOP_SENDING. ngtcp2 shuts the send side and sends
+   RESET_STREAM itself once this returns. A stream handler hears of it here
+   (recv_stop_sending). One built against ABI 1.0 lacks that member, and
+   learns of it only when #write_pkt finds the send side shut
+   (stream_shut_write) or the stream closes. */
+static int quic_recv_stop_sending_cb(ngtcp2_conn *conn, int64_t stream_id,
+                                     uint64_t app_error_code, void *user_data,
+                                     void *stream_user_data) {
+  (void)conn;
+  (void)stream_user_data;
+  quic_conn_t *c = (quic_conn_t *)user_data;
+  if (c->handler) {
+    if (!QUIC_EXT_HANDLER_HAS(c->handler, recv_stop_sending))
+      return 0;
+    return c->handler->recv_stop_sending(c->handler_ud, stream_id,
+                                         app_error_code) < 0
+               ? NGTCP2_ERR_CALLBACK_FAILURE
+               : 0;
+  }
+  struct quic_stream_cb_args a = {
+      .c = c, .stream_id = stream_id, .app_error_code = app_error_code};
+  return quic_conn_protect(c, quic_recv_stop_sending_body, &a);
+}
+
 /* The callbacks below matter only to a stream handler. Without one, the
    QUIC::Stream mode needs none of them. */
 
+/* This endpoint stopped reading the stream, and STOP_SENDING is going out.
+   Not to be confused with recv_stop_sending above. */
 static int quic_stream_stop_sending_cb(ngtcp2_conn *conn, int64_t stream_id,
                                        uint64_t app_error_code, void *user_data,
                                        void *stream_user_data) {
@@ -701,6 +753,7 @@ void quic_conn_fill_common_callbacks(ngtcp2_callbacks *callbacks) {
   callbacks->acked_stream_data_offset = quic_acked_stream_data_offset_cb;
   callbacks->stream_close = quic_stream_close_cb;
   callbacks->stream_reset = quic_stream_reset_cb;
+  callbacks->recv_stop_sending = quic_recv_stop_sending_cb;
   callbacks->stream_stop_sending = quic_stream_stop_sending_cb;
   callbacks->extend_max_stream_data = quic_extend_max_stream_data_cb;
   callbacks->extend_max_remote_streams_bidi =
@@ -708,11 +761,12 @@ void quic_conn_fill_common_callbacks(ngtcp2_callbacks *callbacks) {
   callbacks->handshake_completed = quic_handshake_completed_cb;
 }
 
-/* Find the first stream in @streams that has either pending bytes or a
-   pending FIN to flush. Phase 4 minimum: linear scan, take the first match
-   (no round-robin). Sets *out_datav to the byte slice to send, *out_datavcnt
-   to 0 or 1, *out_flags to NGTCP2_WRITE_STREAM_FLAG_FIN when applicable.
-   Returns the stream's Ruby VALUE (or Qnil if no candidate). */
+/* Find the first stream in @streams, stopped ones aside, that has either
+   pending bytes or a pending FIN to flush. Phase 4 minimum: linear scan,
+   take the first match (no round-robin). Sets *out_datav to the byte slice
+   to send, *out_datavcnt to 0 or 1, *out_flags to
+   NGTCP2_WRITE_STREAM_FLAG_FIN when applicable. Returns the stream's Ruby
+   VALUE (or Qnil if no candidate). */
 static VALUE quic_conn_pick_send_stream(VALUE self, ngtcp2_vec *out_datav,
                                         size_t *out_datavcnt,
                                         uint32_t *out_flags,
@@ -724,7 +778,7 @@ static VALUE quic_conn_pick_send_stream(VALUE self, ngtcp2_vec *out_datav,
     VALUE st = RARRAY_AREF(stream_values, i);
     quic_stream_t *s;
     TypedData_Get_Struct(st, quic_stream_t, &quic_stream_data_type, s);
-    if (s->fin_flushed)
+    if (s->fin_flushed || s->stopped)
       continue;
 
     VALUE pending = rb_ivar_get(st, rb_intern("@pending_chunks"));
@@ -794,11 +848,18 @@ static ngtcp2_ssize quic_conn_write_pkt_streams(VALUE self, quic_conn_t *c,
       c->conn, path, pi, dest, destlen, &pdatalen, writev_flags, send_stream_id,
       &datav, datavcnt, c->now);
 
-  if (n == NGTCP2_ERR_STREAM_DATA_BLOCKED && NIL_P(c->pending_exc)) {
-    /* The stream's queued data is beyond what the peer's flow control lets
-       through right now. Keep it queued and build the packet without it, so
-       that ACKs and other frames still go out; the data follows once the
-       peer extends its window (MAX_STREAM_DATA / MAX_DATA). */
+  if ((n == NGTCP2_ERR_STREAM_DATA_BLOCKED || n == NGTCP2_ERR_STREAM_SHUT_WR) &&
+      NIL_P(c->pending_exc)) {
+    /* DATA_BLOCKED: the stream's queued data is beyond what the peer's flow
+       control lets through right now. Keep it queued; it follows once the
+       peer extends its window (MAX_STREAM_DATA / MAX_DATA).
+       SHUT_WR: ngtcp2 shut the stream's send side without recv_stop_sending
+       marking the stream, as #reset does. What is queued can never go out,
+       so drop it.
+       Either way, build the packet without the stream's data, so that ACKs
+       and other frames still go out. */
+    if (n == NGTCP2_ERR_STREAM_SHUT_WR)
+      quic_stream_stop(selected_stream);
     selected_stream = Qnil;
     datavcnt = 0;
     writev_flags = 0;

data/ext/quic/connection_common.h

@@ -14,6 +14,14 @@
    minimum destlen ngtcp2 accepts. Revisit when PMTUD is enabled (Phase 4+). */
 #define QUIC_WRITE_PKT_BUFLEN NGTCP2_MAX_UDP_PAYLOAD_SIZE
 
+/* Whether the stream handler h has member, judged by the size it was built
+   with: a handler built against an older quic/ext.h is shorter, and its
+   memory ends before the members added since. Compared with the end of the
+   member, not the start of the next one, so trailing padding does not
+   count. */
+#define QUIC_EXT_HANDLER_HAS(h, member)                                        \
+  ((h)->size >= offsetof(quic_ext_stream_handler, member) + sizeof((h)->member))
+
 /* A QUIC::Endpoint (endpoint.c). */
 typedef struct quic_endpoint quic_endpoint_t;
 

data/ext/quic/ext_api.c

@@ -15,14 +15,16 @@ static quic_ext_conn *quic_ext_conn_get(VALUE conn) {
 
 /* Hand every stream of the connection to h. Allowed once, and only before
    the connection has a QUIC::Stream: the two modes cannot share streams.
-   Every member of the ABI 1.0 handler is called, so h must be at least that
-   large. @stream_handler marks the connection for the Ruby side, which then
-   refuses #accept_stream. */
+   Every member of the ABI 1.0 handler is called, so h must hold them all
+   (handshake_completed is the last). A handler built against an older
+   quic/ext.h than this one is shorter than sizeof(quic_ext_stream_handler),
+   and is called only for the members its size covers. @stream_handler marks
+   the connection for the Ruby side, which then refuses #accept_stream. */
 static int quic_ext_set_stream_handler(quic_ext_conn *ec,
                                        const quic_ext_stream_handler *h,
                                        void *ud, VALUE owner) {
   quic_conn_t *c = quic_ext_conn_struct(ec);
-  if (h == NULL || h->size < sizeof(quic_ext_stream_handler))
+  if (h == NULL || !QUIC_EXT_HANDLER_HAS(h, handshake_completed))
     return QUIC_EXT_ERR_OTHER;
   if (c->handler != NULL)
     return QUIC_EXT_ERR_INVALID_STATE;
@@ -93,7 +95,7 @@ static int quic_ext_set_application_error(quic_ext_conn *ec,
 
 const quic_ext_api quic_ext_api_table = {
     .abi_major = QUIC_EXT_ABI_MAJOR,
-    .abi_minor = 0,
+    .abi_minor = QUIC_EXT_ABI_MINOR,
     .size = sizeof(quic_ext_api),
     .conn_get = quic_ext_conn_get,
     .set_stream_handler = quic_ext_set_stream_handler,

data/ext/quic/extconf.rb

@@ -5,11 +5,11 @@ require "mini_portile2"
 require "shellwords"
 require "fileutils"
 
-NGTCP2_VERSION = "1.25.0"
-NGTCP2_SHA256 = "1c0843076528a87b65e9a9d455100941f4cb65d44f96c5da6ae56df146043955"
-# The picotls revision that ngtcp2 1.25.0 is tested against (see ngtcp2's README).
-PICOTLS_COMMIT = "f07f1c8c68b237f1468bc1f1fe1b68aba3ff23b4"
-PICOTLS_SHA256 = "6ecb4f8d9946c2b9342300b29627dc34e746a551d438d35af325a4495d62a6e3"
+NGTCP2_VERSION = "1.26.0"
+NGTCP2_SHA256 = "85174d674e7f8fd911a827c6e483fd417b21b1f54d7853dac464cee446c8d35f"
+# The picotls revision that ngtcp2 1.26.0 is tested against (see ngtcp2's README).
+PICOTLS_COMMIT = "a2d95de4c875d6dcb27658e476e3b624f4381bf0"
+PICOTLS_SHA256 = "d54263601c4652ef28451533bb2e2fae3f5f44aff54338cf5110b9c12c4bab3a"
 # Bump when ext/quic/patches/picotls/ or PicotlsRecipe::SOURCES changes;
 # installed? only checks for the archive.
 PICOTLS_PATCH_LEVEL = "p2"

data/ext/quic/include/quic/ext.h

@@ -14,7 +14,13 @@
  *   the table's. The structs below grow only by appending, which bumps
  *   abi_minor; reordering, removing or retyping a member bumps abi_major.
  *   Check `size` before calling a member added after the version you were
- *   built against. The handler struct follows the same rules.
+ *   built against. The handler struct follows the same rules:
+ *   set_stream_handler takes any handler at least as large as the ABI 1.0
+ *   one, and quic.so calls a member added later only when the handler's
+ *   `size` covers it. Every member `size` covers must be non-NULL.
+ *   A member added after ABI 1.0 is marked with the minor that brought it
+ *   (abi_minor N), and quic.so calls a handler member only when the table's
+ *   abi_minor is at least that N: an older quic.so leaves it uncalled.
  * - Exceptions: no function in the table and no handler function raises a
  *   Ruby exception; they return 0 or a negative error code. The one
  *   exception is conn_get, which raises TypeError for a wrong object and is
@@ -37,6 +43,8 @@
 #include <stdint.h>
 
 #define QUIC_EXT_ABI_MAJOR 1
+/* The abi_minor of the structs as this header declares them. */
+#define QUIC_EXT_ABI_MINOR 1
 
 #define QUIC_EXT_ERR_INVALID_STATE (-1)
 #define QUIC_EXT_ERR_STREAM_ID_BLOCKED (-2)
@@ -67,6 +75,19 @@ typedef struct {
   int (*stream_close)(void *ud, int64_t id, int has_code,
                       uint64_t app_error_code);
   int (*handshake_completed)(void *ud);
+  /* abi_minor 1 */
+  /* The peer sent STOP_SENDING on stream id, which this endpoint sends on
+     (stream_stop_sending is the other way: this endpoint stopped reading).
+     Called once per stream. Once it returns 0, ngtcp2 shuts the send side
+     and sends RESET_STREAM carrying app_error_code, unless all that was
+     sent, FIN included, has been acknowledged. next_stream_data should no
+     longer offer the stream; if it does, stream_shut_write follows. It can
+     come before any recv_stream_data, for a stream the peer has just
+     opened, and also comes for a unidirectional stream this endpoint
+     opened. stream_close may follow within the same #read_pkt. Calling
+     shutdown_stream_write here sends RESET_STREAM with that code instead,
+     but stream_close still reports app_error_code. */
+  int (*recv_stop_sending)(void *ud, int64_t id, uint64_t app_error_code);
 } quic_ext_stream_handler;
 
 typedef struct {

data/ext/quic/stream.c

@@ -45,6 +45,19 @@ quic_stream_new(int64_t stream_id, VALUE owner) {
   return self;
 }
 
+/* Raise QUIC::Error::StreamClosed if nothing more can be written to the
+   stream: it was reset or has closed, or the peer sent STOP_SENDING. */
+static void quic_stream_check_writable(quic_stream_t *s) {
+  if (s->reset || s->closed) {
+    rb_raise(rb_eQUICErrorStreamClosed, "stream is closed");
+  }
+  if (s->stopped) {
+    rb_raise(rb_eQUICErrorStreamClosed,
+             "the peer asked to stop sending (error code %llu)",
+             (unsigned long long)s->stop_app_error_code);
+  }
+}
+
 /* Append a binary copy of |data| to @pending_chunks and optionally set the
    fin_sent flag. Flow control is the caller's concern (#write blocks in
    quic_stream_write_m and #write_nonblock returns a partial byte count in
@@ -55,9 +68,7 @@ static VALUE quic_stream_enqueue(VALUE self, VALUE data, bool fin) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
-  if (s->reset || s->closed) {
-    rb_raise(rb_eQUICErrorStreamClosed, "stream is closed");
-  }
+  quic_stream_check_writable(s);
   if (s->fin_sent) {
     rb_raise(rb_eQUICErrorStreamClosed, "stream FIN already sent");
   }
@@ -94,7 +105,9 @@ static bool quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data) {
    per-stream and the per-connection flow control limits ngtcp2 tracks, less
    the bytes already queued in @pending_chunks but not yet handed to ngtcp2.
    ngtcp2 only counts what it has sent, so without the subtraction a run of
-   writes could queue far more than the peer allows. */
+   writes could queue far more than the peer allows. Callers check the
+   stream is writable first: a stopped stream's @pending_chunks no longer
+   matches its offsets. */
 static uint64_t quic_stream_window_left(VALUE self, VALUE client_v,
                                         quic_stream_t *s) {
   ngtcp2_conn *conn = quic_conn_ptr(client_v);
@@ -117,8 +130,10 @@ static uint64_t quic_stream_window_left(VALUE self, VALUE client_v,
 /* Blocking write: block by repeatedly invoking #pump_once on the owning
    connection (@client) until the peer's flow control window has enough room
    for the full payload, then enqueue. IO#write-compatible: always queues all
-   of `data`. Bare Streams (built via QUIC::Stream.allocate for unit tests,
-   with @client = nil) skip the window check entirely. */
+   of `data`. A window that can no longer open, because the peer sent
+   STOP_SENDING or the stream ended meanwhile, raises
+   QUIC::Error::StreamClosed. Bare Streams (built via QUIC::Stream.allocate
+   for unit tests, with @client = nil) skip the window check entirely. */
 static VALUE quic_stream_write_m(int argc, VALUE *argv, VALUE self) {
   VALUE data;
   bool fin = quic_stream_fin_kwarg(argc, argv, &data);
@@ -139,8 +154,10 @@ static VALUE quic_stream_write_m(int argc, VALUE *argv, VALUE self) {
     /* Loop until the full payload would fit in the current window. pump_once
        raises QUIC::Error::NotBound if the connection has not been #bind'ed;
        that error surfaces verbatim. */
+    quic_stream_check_writable(s);
     while ((uint64_t)needed > quic_stream_window_left(self, client_v, s)) {
       rb_funcall(client_v, rb_intern("pump_once"), 0);
+      quic_stream_check_writable(s);
     }
   }
 
@@ -172,6 +189,8 @@ static VALUE quic_stream_write_nonblock_m(int argc, VALUE *argv, VALUE self) {
 
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
+  /* Before the window: a stream that cannot be written to never gets one. */
+  quic_stream_check_writable(s);
   uint64_t avail = quic_stream_window_left(self, client_v, s);
 
   if (avail == 0) {

data/ext/quic/stream.h

@@ -29,6 +29,12 @@ typedef struct {
   bool closed;       /* stream_close callback fired */
   uint64_t close_app_error_code;
   bool close_has_app_error_code;
+  /* The send side is shut: the peer's STOP_SENDING arrived, or ngtcp2
+     reported the send side shut while writing. @pending_chunks has been
+     emptied, so the offsets above no longer describe it, and #write_pkt
+     skips the stream. */
+  bool stopped;
+  uint64_t stop_app_error_code; /* the STOP_SENDING's, 0 if none arrived */
   /* Set once a peer-initiated stream has been pushed onto the owning
      connection's @accept_queue, so recv_stream_data does not enqueue it
      again on subsequent data arrivals. */

data/lib/quic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QUIC
-  VERSION = "0.0.4"
+  VERSION = "0.0.6"
 end

data/sig/quic.rbs

@@ -323,15 +323,19 @@ module QUIC
     # Server) until the peer's flow control window has room for the full
     # payload, then queues all bytes and returns data.bytesize. Requires the
     # owning connection to be bound to a socket via #bind; raises
-    # QUIC::Error::NotBound otherwise.
+    # QUIC::Error::NotBound otherwise. Raises QUIC::Error::StreamClosed,
+    # while waiting too, once the stream has been reset or closed, or the
+    # peer has sent STOP_SENDING. STOP_SENDING also drops what was queued
+    # but not yet sent.
     def write: (String data, ?fin: bool) -> Integer
 
     # Non-blocking variant. Queues as much of `data` as the current flow
     # control window allows and returns the byte count actually queued.
     # Raises QUIC::Error::WaitWritable (mixed in with IO::WaitWritable) when
-    # the window is zero and the payload is non-empty. If only a partial
-    # prefix is accepted, `fin: true` is NOT propagated; the caller must
-    # re-issue with `fin: true` on the trailing chunk.
+    # the window is zero and the payload is non-empty, and
+    # QUIC::Error::StreamClosed as #write does. If only a partial prefix is
+    # accepted, `fin: true` is NOT propagated; the caller must re-issue with
+    # `fin: true` on the trailing chunk.
     def write_nonblock: (String data, ?fin: bool) -> Integer
     def eof?: () -> bool
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quic
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Yusuke Nakamura