quic 0.0.6 → 0.0.7

data/ext/quic/connection_common.h

@@ -65,11 +65,18 @@ typedef struct {
      ptls_get_data_ptr. The ref must outlive the ptls_t. */
   ngtcp2_crypto_conn_ref conn_ref;
   /* Back-reference to the Client or Server Ruby object that owns this
-     struct. ngtcp2 stream callbacks receive a void* user_data equal to this
-     struct, and they look up @streams via owner. We are stored INSIDE owner
-     via TypedData_Wrap_Struct, so owner is guaranteed alive while we exist
-     (no dmark needed). GC.compact may relocate owner, so quic_conn_compact
-     updates this field via rb_gc_location. */
+     struct. ngtcp2 callbacks receive a void* user_data equal to this
+     struct, and reach @streams and @accept_queue via owner. We are stored
+     INSIDE owner via TypedData_Wrap_Struct, so owner is guaranteed alive
+     while we exist (no dmark needed). GC.compact may relocate owner, so
+     quic_conn_compact updates this field via rb_gc_location.
+
+     A stream's callbacks get its QUIC::Stream's quic_stream_t from
+     ngtcp2's stream_user_data, which is only safe while @streams keeps
+     that Stream alive. So a Stream goes into @streams before ngtcp2 is
+     given its struct, and leaves only at the end of the stream_close
+     callback, which must not fail after that: a failing stream_close
+     leaves the stream in ngtcp2, pointing at a struct GC may free. */
   VALUE owner;
   /* An exception raised by Ruby code inside an ngtcp2 callback, caught with
      rb_protect so that it does not unwind through ngtcp2's frames. #read_pkt,
@@ -94,6 +101,11 @@ typedef struct {
   /* Set by the constructor. Decides which peer-initiated streams
      recv_stream_data queues for #accept_stream. */
   bool is_server;
+  /* The bytes the QUIC::Streams of this connection have queued and not yet
+     handed to ngtcp2, stopped streams excepted. ngtcp2 takes off the
+     connection's flow control window only what it has sent, so #write and
+     #write_nonblock take this off as well. */
+  uint64_t stream_unsent;
   /* <qlog_dir>/<SCID>.sqlog while ngtcp2 writes qlog to it, else NULL.
      quic_conn_close_qlog closes it as soon as the connection ends;
      NGTCP2_QLOG_WRITE_FLAG_FIN, sent by ngtcp2_conn_del, closes one still
@@ -134,6 +146,12 @@ VALUE quic_conn_alloc(VALUE klass);
 /* CLOCK_MONOTONIC in ngtcp2's units (nanoseconds). */
 ngtcp2_tstamp quic_now(void);
 
+/* Run body(arg), Ruby code an ngtcp2 callback of c calls, under rb_protect.
+   An exception is kept in c->pending_exc (the first one wins; ngtcp2 stops
+   at the first failing callback anyway) and turned into
+   NGTCP2_ERR_CALLBACK_FAILURE, so that it never unwinds through ngtcp2. */
+int quic_conn_protect(quic_conn_t *c, VALUE (*body)(VALUE), void *arg);
+
 /* Build the next packet of the connection self (wrapping c) into dest of
    QUIC_WRITE_PKT_BUFLEN bytes, as #write_pkt does, and store its path in
    *path. Returns the packet's length, 0 when there is nothing to send, or a

data/ext/quic/stream.c

@@ -5,19 +5,44 @@
 
 VALUE rb_cQUICStream;
 
-static void quic_stream_free(void *ptr) { xfree(ptr); }
+/* Free the whole send buffer. Safe to call more than once. */
+static void quic_stream_free_send_buffer(quic_stream_t *s) {
+  quic_send_chunk *chunk = s->send_head;
+  while (chunk != NULL) {
+    quic_send_chunk *next = chunk->next;
+    xfree(chunk);
+    chunk = next;
+  }
+  s->send_head = NULL;
+  s->send_tail = NULL;
+  s->send_next = NULL;
+  s->send_next_off = 0;
+  s->buffered = 0;
+}
+
+/* Touches neither the connection nor any Ruby object: the connection may
+   have been freed first, in the same GC. */
+static void quic_stream_free(void *ptr) {
+  quic_stream_free_send_buffer((quic_stream_t *)ptr);
+  xfree(ptr);
+}
 
 static size_t quic_stream_size(const void *ptr) {
-  (void)ptr;
-  return sizeof(quic_stream_t);
+  return sizeof(quic_stream_t) + ((const quic_stream_t *)ptr)->buffered;
+}
+
+static void quic_stream_compact(void *ptr) {
+  quic_stream_t *s = (quic_stream_t *)ptr;
+  s->self = rb_gc_location(s->self);
 }
 
-const rb_data_type_t quic_stream_data_type = {
+static const rb_data_type_t quic_stream_data_type = {
     "QUIC::Stream",
     {
         NULL,
         quic_stream_free,
         quic_stream_size,
+        quic_stream_compact,
     },
     NULL,
     NULL,
@@ -27,11 +52,16 @@ const rb_data_type_t quic_stream_data_type = {
 static VALUE quic_stream_alloc(VALUE klass) {
   quic_stream_t *s = ALLOC(quic_stream_t);
   memset(s, 0, sizeof(*s));
-  return TypedData_Wrap_Struct(klass, &quic_stream_data_type, s);
+  VALUE self = TypedData_Wrap_Struct(klass, &quic_stream_data_type, s);
+  s->self = self;
+  return self;
 }
 
-VALUE
-quic_stream_new(int64_t stream_id, VALUE owner) {
+/* Allocate a new QUIC::Stream Ruby object for stream_id with a
+   zero-initialized quic_stream_t, and set its ivars (@id / @client /
+   @recv_buffer). @client is owner, the Client or Server the stream belongs
+   to; the ivar keeps its name for both. */
+static VALUE quic_stream_new(int64_t stream_id, VALUE owner) {
   VALUE self = quic_stream_alloc(rb_cQUICStream);
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
@@ -39,7 +69,6 @@ quic_stream_new(int64_t stream_id, VALUE owner) {
 
   rb_ivar_set(self, rb_intern("@id"), LL2NUM(stream_id));
   rb_ivar_set(self, rb_intern("@client"), owner);
-  rb_ivar_set(self, rb_intern("@pending_chunks"), rb_ary_new());
   /* recv_buffer is a binary String; rb_str_buf_new returns ASCII-8BIT. */
   rb_ivar_set(self, rb_intern("@recv_buffer"), rb_str_buf_new(0));
   return self;
@@ -58,11 +87,11 @@ static void quic_stream_check_writable(quic_stream_t *s) {
   }
 }
 
-/* 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
-   quic_stream_write_nonblock_m). This helper is reached only after the
-   caller has confirmed the bytes fit in the current send window, so it
+/* Append a copy of |data| to the send buffer as one chunk, 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 quic_stream_write_nonblock_m). This helper is reached only after
+   the caller has confirmed the bytes fit in the current send window, so it
    never raises QUIC::Error::WaitWritable on its own. */
 static VALUE quic_stream_enqueue(VALUE self, VALUE data, bool fin) {
   quic_stream_t *s;
@@ -77,12 +106,31 @@ static VALUE quic_stream_enqueue(VALUE self, VALUE data, bool fin) {
   long len = RSTRING_LEN(data);
 
   if (len > 0) {
-    VALUE chunk = rb_str_new(RSTRING_PTR(data), len);
-    /* rb_str_new returns ASCII-8BIT, so no encoding adjustment is needed.
-       Force it explicitly to be defensive against future CRuby changes. */
-    rb_enc_associate_index(chunk, rb_ascii8bit_encindex());
-    VALUE pending = rb_ivar_get(self, rb_intern("@pending_chunks"));
-    rb_ary_push(pending, chunk);
+    /* A bare Stream has no connection to count its bytes against. */
+    VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
+    quic_conn_t *c = NIL_P(client_v) ? NULL : quic_conn_get(client_v);
+
+    /* len is a long, so the header cannot overflow size_t. */
+    size_t size = offsetof(quic_send_chunk, data) + (size_t)len;
+    quic_send_chunk *chunk = (quic_send_chunk *)xmalloc(size);
+    chunk->next = NULL;
+    chunk->len = (size_t)len;
+    memcpy(chunk->data, RSTRING_PTR(data), (size_t)len);
+    if (s->send_tail != NULL) {
+      s->send_tail->next = chunk;
+    } else {
+      s->send_head = chunk;
+      s->head_offset = s->queued_offset;
+    }
+    s->send_tail = chunk;
+    if (s->send_next == NULL) {
+      s->send_next = chunk;
+      s->send_next_off = 0;
+    }
+    s->queued_offset += (uint64_t)len;
+    s->buffered += size;
+    if (c != NULL)
+      c->stream_unsent += (uint64_t)len;
   }
 
   if (fin) {
@@ -102,29 +150,365 @@ static bool quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data) {
 }
 
 /* Return the effective send window for this stream: the smaller of the
-   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. 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);
+   per-stream and the per-connection flow control limits ngtcp2 tracks,
+   each less the bytes already queued against it but not yet handed to
+   ngtcp2 (this stream's, and every stream's of the connection). ngtcp2 only
+   counts what it has sent, so without the subtraction a run of writes could
+   queue far more than the peer allows. Callers check the stream is
+   writable first. */
+static uint64_t quic_stream_window_left(VALUE client_v, quic_stream_t *s) {
+  quic_conn_t *c = quic_conn_get(client_v);
   uint64_t stream_left =
-      ngtcp2_conn_get_max_stream_data_left2(conn, s->stream_id);
-  uint64_t conn_left = ngtcp2_conn_get_max_data_left2(conn);
-  uint64_t left = stream_left < conn_left ? stream_left : conn_left;
-
-  /* @pending_chunks starts at stream offset pending_shifted, and the bytes
-     up to sent_offset have been sent. */
-  VALUE pending = rb_ivar_get(self, rb_intern("@pending_chunks"));
-  uint64_t queued_end = s->pending_shifted;
-  for (long i = 0; i < RARRAY_LEN(pending); i++) {
-    queued_end += (uint64_t)RSTRING_LEN(RARRAY_AREF(pending, i));
+      ngtcp2_conn_get_max_stream_data_left2(c->conn, s->stream_id);
+  uint64_t conn_left = ngtcp2_conn_get_max_data_left2(c->conn);
+
+  uint64_t unsent = s->queued_offset - s->sent_offset;
+  stream_left = stream_left > unsent ? stream_left - unsent : 0;
+  conn_left = conn_left > c->stream_unsent ? conn_left - c->stream_unsent : 0;
+  return stream_left < conn_left ? stream_left : conn_left;
+}
+
+/* What s has to send next: the unsent part of the chunk at send_next in
+   *datav (*datavcnt = 1), or nothing but a FIN (*datavcnt = 0). *flags gets
+   NGTCP2_WRITE_STREAM_FLAG_FIN when the FIN goes with it, that is when the
+   chunk is the last one queued. Returns false when s has nothing to send,
+   which includes a stopped stream. */
+static bool quic_stream_next_send(const quic_stream_t *s, ngtcp2_vec *datav,
+                                  size_t *datavcnt, uint32_t *flags) {
+  if (s->stopped || s->fin_flushed)
+    return false;
+
+  if (s->send_next != NULL) {
+    datav->base = s->send_next->data + s->send_next_off;
+    datav->len = s->send_next->len - s->send_next_off;
+    *datavcnt = 1;
+    /* FIN goes with the last chunk only if ngtcp2 frames all of it; when
+       it encodes less, FIN is not flushed and the next call retries. */
+    *flags = (s->fin_sent && s->send_next == s->send_tail)
+                 ? NGTCP2_WRITE_STREAM_FLAG_FIN
+                 : 0;
+    return true;
+  }
+
+  if (s->fin_sent) {
+    /* No data to send but a pending FIN-only frame. */
+    datav->base = NULL;
+    datav->len = 0;
+    *datavcnt = 0;
+    *flags = NGTCP2_WRITE_STREAM_FLAG_FIN;
+    return true;
+  }
+  return false;
+}
+
+/* Account for a packet ngtcp2_conn_writev_stream built for c from what
+   quic_stream_next_send offered: datalen bytes (0 for a FIN alone) with
+   flags, of which ngtcp2 framed pdatalen, in a packet of n bytes. */
+static void quic_stream_sent(quic_conn_t *c, quic_stream_t *s, size_t datalen,
+                             uint32_t flags, ngtcp2_ssize pdatalen,
+                             ngtcp2_ssize n) {
+  if (pdatalen > 0) {
+    s->sent_offset += (uint64_t)pdatalen;
+    c->stream_unsent -= (uint64_t)pdatalen;
+    s->send_next_off += (size_t)pdatalen;
+    /* Leave send_next on no fully handed over chunk: an acknowledgement
+       of all that was sent would free it under us. */
+    if (s->send_next_off == s->send_next->len) {
+      s->send_next = s->send_next->next;
+      s->send_next_off = 0;
+    }
+    /* FIN is only actually written when all requested data fits in the
+       frame (see ngtcp2 docs on NGTCP2_WRITE_STREAM_FLAG_FIN). */
+    if ((flags & NGTCP2_WRITE_STREAM_FLAG_FIN) && (size_t)pdatalen == datalen)
+      s->fin_flushed = true;
+  } else if (datalen == 0 && n > 0 && (flags & NGTCP2_WRITE_STREAM_FLAG_FIN)) {
+    /* FIN-only packet (no data) was successfully written. */
+    s->fin_flushed = true;
+  }
+}
+
+/* Shut the send side of s, a stream of c (NULL for a bare Stream): nothing
+   it has queued goes out any more. Does nothing the second time. The send
+   buffer stays until the stream closes. On STOP_SENDING ngtcp2 calls
+   recv_stop_sending before it drops the frames it queued for the stream,
+   which still point into the buffer, and should it fail in between it keeps
+   them. */
+static void quic_stream_stop(quic_conn_t *c, quic_stream_t *s) {
+  if (s->stopped)
+    return;
+  s->stopped = true;
+  if (c != NULL)
+    c->stream_unsent -= s->queued_offset - s->sent_offset;
+}
+
+/* Make a QUIC::Stream for stream_id, a stream ngtcp2 has just opened on the
+   connection owner (wrapping c), put it in @streams, and only then hand its
+   quic_stream_t to ngtcp2 as the stream's stream_user_data: ngtcp2 must
+   never point at a Stream that @streams does not keep alive (see
+   quic_conn_t.owner). Returns the Stream. */
+static VALUE quic_stream_add(VALUE owner, quic_conn_t *c, int64_t stream_id) {
+  VALUE stream = quic_stream_new(stream_id, owner);
+  VALUE streams = rb_ivar_get(owner, rb_intern("@streams"));
+  rb_hash_aset(streams, LL2NUM(stream_id), stream);
+
+  quic_stream_t *s;
+  TypedData_Get_Struct(stream, quic_stream_t, &quic_stream_data_type, s);
+  int rv = ngtcp2_conn_set_stream_user_data(c->conn, stream_id, s);
+  if (rv != 0)
+    quic_raise_ngtcp2_error(rv);
+  return stream;
+}
+
+VALUE quic_stream_open_local(VALUE self, quic_conn_t *c, int64_t stream_id) {
+  return quic_stream_add(self, c, stream_id);
+}
+
+/* The callbacks that touch Ruby objects (on_open, on_recv_data and
+   on_close) do that in a *_body function run under rb_protect by
+   quic_conn_protect, so that an exception (a frozen @streams, an allocation
+   failure, ...) never unwinds through ngtcp2. The callback then returns
+   NGTCP2_ERR_CALLBACK_FAILURE and the exception is re-raised once ngtcp2
+   has returned. */
+
+/* The arguments of a stream callback, handed to its body through
+   rb_protect's single VALUE. Each body reads only the fields it needs. */
+struct quic_stream_cb_args {
+  quic_conn_t *c;
+  quic_stream_t *s;
+  int64_t stream_id;
+  uint32_t flags;
+  const uint8_t *data;
+  size_t datalen;
+  uint64_t app_error_code;
+};
+
+static VALUE quic_stream_on_open_body(VALUE arg) {
+  struct quic_stream_cb_args *a = (struct quic_stream_cb_args *)arg;
+  quic_stream_add(a->c->owner, a->c, a->stream_id);
+  return Qnil;
+}
+
+/* Called only for a stream the peer opened. */
+int quic_stream_on_open(quic_conn_t *c, int64_t stream_id) {
+  struct quic_stream_cb_args a = {.c = c, .stream_id = stream_id};
+  return quic_conn_protect(c, quic_stream_on_open_body, &a);
+}
+
+static VALUE quic_stream_on_recv_data_body(VALUE arg) {
+  struct quic_stream_cb_args *a = (struct quic_stream_cb_args *)arg;
+  quic_conn_t *c = a->c;
+  quic_stream_t *s = a->s;
+  VALUE stream = s->self;
+
+  /* Surface peer-initiated streams to #accept_stream. The low stream-id bit
+     marks the initiator (0 == client, 1 == server), so a client queues the
+     odd ids and a server the even ones. Push once, on first data arrival,
+     then mark so later data does not re-enqueue. */
+  bool peer_initiated =
+      c->is_server ? !(s->stream_id & 0x01) : (s->stream_id & 0x01);
+  if (!s->accept_queued && peer_initiated) {
+    VALUE accept_queue = rb_ivar_get(c->owner, rb_intern("@accept_queue"));
+    rb_ary_push(accept_queue, stream);
+    s->accept_queued = true;
+  }
+
+  if (a->datalen > 0) {
+    VALUE recv_buffer = rb_ivar_get(stream, rb_intern("@recv_buffer"));
+    rb_str_buf_cat(recv_buffer, (const char *)a->data, (long)a->datalen);
+  }
+  if (a->flags & NGTCP2_STREAM_DATA_FLAG_FIN) {
+    s->fin_received = true;
+  }
+  return Qnil;
+}
+
+int quic_stream_on_recv_data(quic_conn_t *c, quic_stream_t *s, uint32_t flags,
+                             const uint8_t *data, size_t datalen) {
+  if (s == NULL)
+    return 0;
+  struct quic_stream_cb_args a = {
+      .c = c,
+      .s = s,
+      .flags = flags,
+      .data = data,
+      .datalen = datalen,
+  };
+  return quic_conn_protect(c, quic_stream_on_recv_data_body, &a);
+}
+
+/* The peer acknowledged [offset, offset + datalen): free the chunks that
+   end at or before offset + datalen. */
+void quic_stream_on_acked(quic_stream_t *s, uint64_t offset, uint64_t datalen) {
+  if (s == NULL)
+    return;
+  /* ngtcp2 reports the acknowledged ranges of a stream in order and
+     without overlap; datalen is 0 only for a FIN alone. */
+  s->acked_offset = offset + datalen;
+  while (s->send_head != NULL &&
+         s->head_offset + s->send_head->len <= s->acked_offset) {
+    quic_send_chunk *chunk = s->send_head;
+    s->head_offset += chunk->len;
+    s->send_head = chunk->next;
+    if (s->send_head == NULL)
+      s->send_tail = NULL;
+    s->buffered -= offsetof(quic_send_chunk, data) + chunk->len;
+    xfree(chunk);
+  }
+}
+
+static VALUE quic_stream_on_close_body(VALUE arg) {
+  struct quic_stream_cb_args *a = (struct quic_stream_cb_args *)arg;
+  quic_stream_t *s = a->s;
+  s->closed = true;
+  if (a->flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET) {
+    s->close_has_app_error_code = true;
+    s->close_app_error_code = a->app_error_code;
+  }
+  /* Usually stopped already, or with nothing left unsent. */
+  quic_stream_stop(a->c, s);
+  /* ngtcp2 never reads the stream's data again. */
+  quic_stream_free_send_buffer(s);
+  /* A stream still waiting in @accept_queue holds on to what it received.
+     Were the peer given its stream back now, it could open and close
+     streams until the queue had used up our memory, so it gets the stream
+     back only once the application has accepted this one
+     (QUIC::Stream#_accepted). */
+  if (s->accept_queued && !s->accepted) {
+    s->peer_stream_held = true;
+  } else {
+    quic_conn_give_back_peer_stream(a->c->conn, a->stream_id);
   }
-  uint64_t unsent = queued_end - s->sent_offset;
-  return left > unsent ? left - unsent : 0;
+  /* Last, and nothing that can fail after it: should this callback fail,
+     ngtcp2 keeps the stream, and the Stream must stay in @streams. */
+  VALUE streams = rb_ivar_get(a->c->owner, rb_intern("@streams"));
+  rb_hash_delete(streams, LL2NUM(a->stream_id));
+  return Qnil;
+}
+
+int quic_stream_on_close(quic_conn_t *c, quic_stream_t *s, int64_t stream_id,
+                         uint32_t flags, uint64_t app_error_code) {
+  if (s == NULL) {
+    quic_conn_give_back_peer_stream(c->conn, stream_id);
+    return 0;
+  }
+  struct quic_stream_cb_args a = {
+      .c = c,
+      .s = s,
+      .stream_id = stream_id,
+      .flags = flags,
+      .app_error_code = app_error_code,
+  };
+  return quic_conn_protect(c, quic_stream_on_close_body, &a);
+}
+
+void quic_stream_on_reset(quic_stream_t *s, uint64_t app_error_code) {
+  if (s == NULL)
+    return;
+  s->reset = true;
+  s->close_app_error_code = app_error_code;
+  s->close_has_app_error_code = true;
+}
+
+void quic_stream_on_recv_stop_sending(quic_conn_t *c, quic_stream_t *s,
+                                      uint64_t app_error_code) {
+  if (s == NULL)
+    return;
+  s->stop_app_error_code = app_error_code;
+  quic_stream_stop(c, s);
+}
+
+struct quic_pick_send_args {
+  quic_stream_t *picked;
+  ngtcp2_vec *datav;
+  size_t *datavcnt;
+  uint32_t *flags;
+};
+
+static int quic_streams_pick_send_i(VALUE key, VALUE value, VALUE arg) {
+  (void)key;
+  struct quic_pick_send_args *a = (struct quic_pick_send_args *)arg;
+  if (!rb_typeddata_is_kind_of(value, &quic_stream_data_type))
+    return ST_CONTINUE;
+  quic_stream_t *s = (quic_stream_t *)RTYPEDDATA_DATA(value);
+  if (!quic_stream_next_send(s, a->datav, a->datavcnt, a->flags))
+    return ST_CONTINUE;
+  a->picked = s;
+  return ST_STOP;
+}
+
+/* Find the first stream in @streams that has either pending bytes or a
+   pending FIN to flush (linear scan, first match, no round-robin), and
+   what it has to send (quic_stream_next_send). Returns NULL if no stream
+   has anything. Raises nothing, so that #write_pkt fails only for what
+   ngtcp2 reports: a value that is not a QUIC::Stream is skipped, and an
+   @streams that is not a Hash holds no stream (only a test puts either
+   there). rb_hash_foreach raises only when the Hash changes while it
+   iterates, which the callback never does. */
+static quic_stream_t *quic_streams_pick_send(VALUE self, ngtcp2_vec *out_datav,
+                                             size_t *out_datavcnt,
+                                             uint32_t *out_flags) {
+  VALUE streams = rb_ivar_get(self, rb_intern("@streams"));
+  if (!RB_TYPE_P(streams, T_HASH))
+    return NULL;
+
+  struct quic_pick_send_args a = {
+      .picked = NULL,
+      .datav = out_datav,
+      .datavcnt = out_datavcnt,
+      .flags = out_flags,
+  };
+  rb_hash_foreach(streams, quic_streams_pick_send_i, (VALUE)&a);
+  return a.picked;
+}
+
+/* If any stream has pending bytes or a pending FIN, route the packet
+   through ngtcp2_conn_writev_stream so the stream data gets framed
+   alongside connection-level frames. Falls back to conn-only when no stream
+   is queued. */
+ngtcp2_ssize quic_streams_write_pkt(VALUE self, quic_conn_t *c,
+                                    ngtcp2_path *path, ngtcp2_pkt_info *pi,
+                                    uint8_t *dest, size_t destlen) {
+  ngtcp2_vec datav;
+  size_t datavcnt = 0;
+  uint32_t writev_flags = 0;
+  quic_stream_t *selected =
+      quic_streams_pick_send(self, &datav, &datavcnt, &writev_flags);
+
+  ngtcp2_ssize pdatalen = -1;
+  ngtcp2_ssize n = ngtcp2_conn_writev_stream(
+      c->conn, path, pi, dest, destlen, &pdatalen, writev_flags,
+      selected != NULL ? selected->stream_id : -1, &datav, datavcnt, c->now);
+
+  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, and neither
+       recv_stop_sending nor #reset stopped the stream. What is queued can
+       never go out, so stop it now.
+       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(c, selected);
+    selected = NULL;
+    datavcnt = 0;
+    writev_flags = 0;
+    pdatalen = -1;
+    n = ngtcp2_conn_writev_stream(c->conn, path, pi, dest, destlen, &pdatalen,
+                                  0, -1, NULL, 0, c->now);
+  }
+
+  if (n < 0 || !NIL_P(c->pending_exc))
+    return n;
+
+  /* pdatalen >= 0 means ngtcp2 framed that many data bytes into the packet;
+     if 0, no data was framed (but the packet may still contain ACK or other
+     frames). */
+  if (selected != NULL)
+    quic_stream_sent(c, selected, datavcnt > 0 ? datav.len : 0, writev_flags,
+                     pdatalen, n);
+  return n;
 }
 
 /* Blocking write: block by repeatedly invoking #pump_once on the owning
@@ -155,7 +539,7 @@ static VALUE quic_stream_write_m(int argc, VALUE *argv, VALUE self) {
        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)) {
+    while ((uint64_t)needed > quic_stream_window_left(client_v, s)) {
       rb_funcall(client_v, rb_intern("pump_once"), 0);
       quic_stream_check_writable(s);
     }
@@ -191,7 +575,7 @@ static VALUE quic_stream_write_nonblock_m(int argc, VALUE *argv, VALUE self) {
   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);
+  uint64_t avail = quic_stream_window_left(client_v, s);
 
   if (avail == 0) {
     rb_raise(rb_eQUICErrorWaitWritable, "stream send window is full");
@@ -336,17 +720,22 @@ static VALUE quic_stream_reset_m(int argc, VALUE *argv, VALUE self) {
     return Qnil;
   }
 
-  ngtcp2_conn *conn = quic_conn_ptr(client_v);
-  int rv = ngtcp2_conn_shutdown_stream_write(conn, 0, s->stream_id, error_code);
+  quic_conn_t *c = quic_conn_get(client_v);
+  int rv =
+      ngtcp2_conn_shutdown_stream_write(c->conn, 0, s->stream_id, error_code);
   if (rv != 0)
     quic_raise_ngtcp2_error(rv);
   s->reset = true;
+  /* Now, not at the next #write_pkt: until then, what it had queued would
+     keep the other streams' #write_nonblock out of the window. */
+  quic_stream_stop(c, s);
   return Qnil;
 }
 
 /* Called by #accept_stream / #accept_stream_nonblock for the stream they
    take off @accept_queue. A stream that closed while it waited there gives
-   the peer back the stream it used up now (see quic_stream_close_body). */
+   the peer back the stream it used up now (see
+   quic_stream_on_close_body). */
 static VALUE quic_stream_accepted_m(VALUE self) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);