quic 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e019da100b72501ae5f3f097aa00344e763de5483e301b03e619c695e7ed269d
-  data.tar.gz: 922faa6c8b6b96e121849d4f17823e31cbfdeb05da3d93681603c3fb55840127
+  metadata.gz: ebac23fb2ffb37336b61ef65171597216d95ec7a0a43ecb3aabfda810fbb5046
+  data.tar.gz: c78df53ff6e4e56f11a7aa3ae93bb1363090d58acf4e3f5b5b2290208b88fee9
 SHA512:
-  metadata.gz: c1eb1754a7e98f652825f641d0a1bfb2c131d54fcaceffe2867b8000107752d39c7fcc9e739125085c84bb76272306213e5774730e408b4d6cfc2bb6ce61b5c9
-  data.tar.gz: 365881fb77b46679c549f6e19dc5988cd94f62a3ab13ee937e0514d12202a45a63c17501c6bf492b6363b2b33c81894651965f74425e44af37cc2e24f37c0aa5
+  metadata.gz: 34f56bd2d3d86c35bdcbe43e912f3b8ebd30454915332523b97a95a9306cb9febf0a7933f904f5fa3afc40b66014796523f59a6e5c0f47465b4c628db681b7f9
+  data.tar.gz: d00248c71fc9436bec13a5f258038512726c65427fe76315347ba40db071174d1c1b47dbfac02e1d7d46fb4c2e161e190cbaf9cbcf0c947a139ee5162cf2334d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [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/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,51 @@ 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 learns of it when
+   #write_pkt finds the send side shut (stream_shut_write). */
+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)
+    return 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 +745,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 +753,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 +770,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 +840,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/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.5"
 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.5
 platform: ruby
 authors:
 - Yusuke Nakamura