quic 0.0.2 → 0.0.3

data/ext/quic/endpoint.h

@@ -0,0 +1,28 @@
+#ifndef QUIC_ENDPOINT_H
+#define QUIC_ENDPOINT_H 1
+
+#include "connection_common.h"
+
+extern VALUE rb_cQUICEndpoint;
+
+/* The CID table, for the get_new_connection_id2 and remove_connection_id
+   callbacks of a connection the Endpoint holds. conn is that connection's
+   object. Neither touches Ruby objects, so the callbacks need no
+   rb_protect. dissociate leaves an entry that maps to another connection
+   alone. */
+void quic_endpoint_associate_cid(quic_endpoint_t *ep, const ngtcp2_cid *cid, VALUE conn);
+void quic_endpoint_dissociate_cid(quic_endpoint_t *ep, const ngtcp2_cid *cid, VALUE conn);
+
+/* The Stateless Reset token for cid, derived from the Endpoint's secret so
+   that it can be made again for a CID no longer in the table. token is
+   NGTCP2_STATELESS_RESET_TOKENLEN bytes. Returns 0, or -1 on failure. */
+int quic_endpoint_generate_reset_token(const quic_endpoint_t *ep, uint8_t *token,
+                                       const ngtcp2_cid *cid);
+
+/* Connection#close of a connection the Endpoint holds: build the
+   CONNECTION_CLOSE carrying ccerr, queue it for Endpoint#write_pkt and
+   start the closing period. When ngtcp2 cannot build the packet, the
+   connection leaves the table at once. */
+void quic_endpoint_close_conn(quic_endpoint_t *ep, quic_conn_t *c, const ngtcp2_ccerr *ccerr);
+
+#endif /* QUIC_ENDPOINT_H */

data/ext/quic/ext_api.c

@@ -0,0 +1,112 @@
+#include "connection_common.h"
+
+/* The quic_ext_api table of quic/ext.h. A quic_ext_conn * is a quic_conn_t *
+   behind the opaque type. None of these functions raises a Ruby exception
+   except quic_ext_conn_get; they return 0 or a QUIC_EXT_ERR_* code. */
+
+static quic_conn_t *
+quic_ext_conn_struct(quic_ext_conn *ec)
+{
+  return (quic_conn_t *)ec;
+}
+
+/* Raises TypeError unless conn is a QUIC::Connection::Client or Server. */
+static quic_ext_conn *
+quic_ext_conn_get(VALUE conn)
+{
+  return (quic_ext_conn *)rb_check_typeddata(conn, &quic_conn_data_type);
+}
+
+/* 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. */
+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)) return QUIC_EXT_ERR_OTHER;
+  if (c->handler != NULL) return QUIC_EXT_ERR_INVALID_STATE;
+  VALUE streams = rb_ivar_get(c->owner, rb_intern("@streams"));
+  if (RB_TYPE_P(streams, T_HASH) && RHASH_SIZE(streams) > 0) return QUIC_EXT_ERR_INVALID_STATE;
+
+  c->handler = h;
+  c->handler_ud = ud;
+  c->handler_owner = owner;
+  rb_ivar_set(c->owner, rb_intern("@stream_handler"), Qtrue);
+  return 0;
+}
+
+static int
+quic_ext_open_uni_stream(quic_ext_conn *ec, int64_t *id)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  int rv = ngtcp2_conn_open_uni_stream(c->conn, id, NULL);
+  if (rv == NGTCP2_ERR_STREAM_ID_BLOCKED) return QUIC_EXT_ERR_STREAM_ID_BLOCKED;
+  return rv == 0 ? 0 : QUIC_EXT_ERR_OTHER;
+}
+
+/* Give the peer n more bytes of credit on the stream and the connection,
+   for data the handler has now consumed (for HTTP/3, request body handed
+   to the application). */
+static int
+quic_ext_consume(quic_ext_conn *ec, int64_t id, uint64_t n)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  if (ngtcp2_conn_extend_max_stream_offset(c->conn, id, n) != 0) return QUIC_EXT_ERR_OTHER;
+  ngtcp2_conn_extend_max_offset(c->conn, n);
+  return 0;
+}
+
+/* Both return 0 for a stream ngtcp2 no longer knows. */
+static int
+quic_ext_shutdown_stream_read(quic_ext_conn *ec, int64_t id, uint64_t app_error_code)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  return ngtcp2_conn_shutdown_stream_read(c->conn, 0, id, app_error_code) == 0
+    ? 0 : QUIC_EXT_ERR_OTHER;
+}
+
+static int
+quic_ext_shutdown_stream_write(quic_ext_conn *ec, int64_t id, uint64_t app_error_code)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  return ngtcp2_conn_shutdown_stream_write(c->conn, 0, id, app_error_code) == 0
+    ? 0 : QUIC_EXT_ERR_OTHER;
+}
+
+/* This endpoint's initial_max_streams_bidi. nghttp3 needs it at setup;
+   later raises arrive through the extend_max_remote_streams_bidi handler. */
+static uint64_t
+quic_ext_local_max_streams_bidi(quic_ext_conn *ec)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  return ngtcp2_conn_get_local_transport_params2(c->conn)->initial_max_streams_bidi;
+}
+
+/* Remember the application error to close the connection with after the
+   handler reports a failure (for HTTP/3, the H3_* code nghttp3 gave). */
+static int
+quic_ext_set_application_error(quic_ext_conn *ec, uint64_t app_error_code)
+{
+  quic_conn_t *c = quic_ext_conn_struct(ec);
+  ngtcp2_ccerr_set_application_error(&c->close_error, app_error_code, NULL, 0);
+  c->close_error_set = true;
+  return 0;
+}
+
+const quic_ext_api quic_ext_api_table = {
+  .abi_major = QUIC_EXT_ABI_MAJOR,
+  .abi_minor = 0,
+  .size = sizeof(quic_ext_api),
+  .conn_get = quic_ext_conn_get,
+  .set_stream_handler = quic_ext_set_stream_handler,
+  .open_uni_stream = quic_ext_open_uni_stream,
+  .consume = quic_ext_consume,
+  .shutdown_stream_read = quic_ext_shutdown_stream_read,
+  .shutdown_stream_write = quic_ext_shutdown_stream_write,
+  .local_max_streams_bidi = quic_ext_local_max_streams_bidi,
+  .set_application_error = quic_ext_set_application_error,
+};

data/ext/quic/extconf.rb

@@ -10,8 +10,9 @@ NGTCP2_SHA256 = "1c0843076528a87b65e9a9d455100941f4cb65d44f96c5da6ae56df14604395
 # The picotls revision that ngtcp2 1.25.0 is tested against (see ngtcp2's README).
 PICOTLS_COMMIT = "f07f1c8c68b237f1468bc1f1fe1b68aba3ff23b4"
 PICOTLS_SHA256 = "6ecb4f8d9946c2b9342300b29627dc34e746a551d438d35af325a4495d62a6e3"
-# Bump when ext/quic/patches/picotls/ changes; installed? only checks for the archive.
-PICOTLS_PATCH_LEVEL = "p1"
+# Bump when ext/quic/patches/picotls/ or PicotlsRecipe::SOURCES changes;
+# installed? only checks for the archive.
+PICOTLS_PATCH_LEVEL = "p2"
 
 # Locate the host's libcrypto. ngtcp2 and picotls are vendored and statically
 # linked, but the crypto primitives and X.509 come from whatever OpenSSL (or
@@ -39,10 +40,12 @@ end
 openssl_cflags = pkg_config("openssl", "cflags-only-I").to_s.strip
 
 # picotls has no release tarballs, and its CMake build needs the picotest
-# submodule, which GitHub archive tarballs do not contain. Build only the two
-# libraries we need (core + OpenSSL-API backend) into a single libpicotls.a.
+# submodule, which GitHub archive tarballs do not contain. Build only what
+# quic.so uses into a single libpicotls.a: the core and the OpenSSL-API
+# backend. The core's lib/pembase64.c, a PEM loader, is left out; the server
+# reads its certificates with libcrypto instead.
 class PicotlsRecipe < MiniPortile
-  SOURCES = %w[lib/picotls.c lib/hpke.c lib/pembase64.c lib/openssl.c].freeze
+  SOURCES = %w[lib/picotls.c lib/hpke.c lib/openssl.c].freeze
 
   attr_accessor :openssl_cflags
 
@@ -161,4 +164,8 @@ append_cflags("-DQUIC_PICOTLS_COMMIT=\\\"#{PICOTLS_COMMIT}\\\"")
 append_cflags("-fvisibility=hidden")
 append_ldflags("-Wl,--exclude-libs,ALL")  # Unexport symbols from statically linked libraries
 
+# quic/ext.h, the C function table other extensions (the http3 gem) build
+# against. It ships in the gem; QUIC::EXT_INCLUDE_DIR points them here.
+append_cppflags("-I#{File.expand_path("include", __dir__)}")
+
 create_makefile("quic/quic")

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

@@ -0,0 +1,84 @@
+/* quic/ext.h — the C function table quic.so offers to other extensions.
+ *
+ * Another extension (the http3 gem) registers a stream handler on a
+ * connection and drives it through this table instead of QUIC::Stream.
+ * Obtain the table after rb_require("quic") with
+ *
+ *   quic_ext_get_api_fn get =
+ *     (quic_ext_get_api_fn)rb_ext_resolve_symbol("quic/quic", "quic_ext_get_api");
+ *   const quic_ext_api *api = get ? get(QUIC_EXT_ABI_MAJOR) : NULL;
+ *
+ * Rules:
+ *
+ * - Version: quic_ext_get_api(major) returns NULL when major differs from
+ *   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.
+ * - 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
+ *   meant for initialization called from a Ruby method. A handler function
+ *   returning a negative value makes the ngtcp2 callback fail with
+ *   NGTCP2_ERR_CALLBACK_FAILURE.
+ * - Lifetime: `owner` passed to set_stream_handler is marked by the
+ *   connection while it lives. `ud` must not move (allocate it with
+ *   xmalloc, not as a Ruby object), and `h` must outlive the connection
+ *   (a static const struct). quic.so never calls a handler from its dfree,
+ *   and the owner's dfree must not touch the quic_ext_conn.
+ * - Where: table functions may be called from inside handler functions.
+ *   Everything runs with the GVL held.
+ */
+#ifndef QUIC_EXT_H
+#define QUIC_EXT_H 1
+
+#include <stddef.h>
+#include <stdint.h>
+#include <ruby.h>
+
+#define QUIC_EXT_ABI_MAJOR 1
+
+#define QUIC_EXT_ERR_INVALID_STATE     (-1)
+#define QUIC_EXT_ERR_STREAM_ID_BLOCKED (-2)
+#define QUIC_EXT_ERR_STREAM_NOT_FOUND  (-3)
+#define QUIC_EXT_ERR_OTHER             (-99)
+
+typedef struct { const uint8_t *base; size_t len; } quic_ext_vec;  /* same layout as ngtcp2_vec */
+typedef struct quic_ext_conn quic_ext_conn;                        /* opaque */
+
+typedef struct {
+  size_t size;  /* sizeof(quic_ext_stream_handler); tells which members exist */
+  int (*recv_stream_data)(void *ud, int64_t id, const uint8_t *data, size_t len,
+                          int fin, uint64_t ts, size_t *consumed);
+  int (*next_stream_data)(void *ud, int64_t *id, int *fin,
+                          quic_ext_vec *vecs, size_t cap, size_t *nvecs);
+  int (*stream_data_written)(void *ud, int64_t id, size_t n);
+  int (*stream_blocked)(void *ud, int64_t id);
+  int (*stream_shut_write)(void *ud, int64_t id);
+  int (*acked_stream_data)(void *ud, int64_t id, uint64_t n);
+  int (*extend_max_stream_data)(void *ud, int64_t id);
+  int (*extend_max_remote_streams_bidi)(void *ud, uint64_t max);
+  int (*stream_stop_sending)(void *ud, int64_t id, uint64_t app_error_code);
+  int (*stream_reset)(void *ud, int64_t id, uint64_t final_size, uint64_t app_error_code);
+  int (*stream_close)(void *ud, int64_t id, int has_code, uint64_t app_error_code);
+  int (*handshake_completed)(void *ud);
+} quic_ext_stream_handler;
+
+typedef struct {
+  uint32_t abi_major;  /* bumped only to break compatibility */
+  uint32_t abi_minor;  /* bumped whenever a member is appended */
+  size_t size;         /* sizeof(quic_ext_api) */
+  quic_ext_conn *(*conn_get)(VALUE conn);  /* TypeError for a wrong object */
+  int (*set_stream_handler)(quic_ext_conn *c, const quic_ext_stream_handler *h,
+                            void *ud, VALUE owner);
+  int (*open_uni_stream)(quic_ext_conn *c, int64_t *id);
+  int (*consume)(quic_ext_conn *c, int64_t id, uint64_t n);
+  int (*shutdown_stream_read)(quic_ext_conn *c, int64_t id, uint64_t app_error_code);
+  int (*shutdown_stream_write)(quic_ext_conn *c, int64_t id, uint64_t app_error_code);
+  uint64_t (*local_max_streams_bidi)(quic_ext_conn *c);
+  int (*set_application_error)(quic_ext_conn *c, uint64_t app_error_code);
+} quic_ext_api;
+
+typedef const quic_ext_api *(*quic_ext_get_api_fn)(uint32_t abi_major);
+
+#endif /* QUIC_EXT_H */

data/ext/quic/quic.c

@@ -1,9 +1,11 @@
 #include "quic.h"
 #include "stream.h"
+#include "connection_common.h"
 
 VALUE rb_mQUIC;
 VALUE rb_mQUICConnection;
 VALUE rb_cQUICConnectionClient;
+VALUE rb_cQUICConnectionServer;
 
 VALUE rb_eQUICError;
 VALUE rb_eQUICErrorProto;
@@ -20,6 +22,17 @@ VALUE rb_eQUICErrorWaitWritable;
 VALUE rb_eQUICErrorStreamClosed;
 VALUE rb_eQUICErrorStreamReset;
 VALUE rb_eQUICErrorNotBound;
+VALUE rb_eQUICErrorInvalidState;
+
+/* The one symbol besides Init_quic that quic.so exports: other extensions
+   look it up with rb_ext_resolve_symbol("quic/quic", "quic_ext_get_api")
+   and get the C function table declared in quic/ext.h. NULL means the
+   caller was built against an incompatible major version. */
+RUBY_FUNC_EXPORTED const quic_ext_api *
+quic_ext_get_api(uint32_t abi_major)
+{
+  return abi_major == QUIC_EXT_ABI_MAJOR ? &quic_ext_api_table : NULL;
+}
 
 static VALUE
 quic_library_versions(VALUE self)
@@ -37,8 +50,8 @@ quic_library_versions(VALUE self)
   return h;
 }
 
-void
-quic_raise_ngtcp2_error(int rv)
+VALUE
+quic_ngtcp2_error_new(int rv)
 {
   VALUE cls;
   switch (rv) {
@@ -77,7 +90,13 @@ quic_raise_ngtcp2_error(int rv)
 
   VALUE exc = rb_exc_new_cstr(cls, ngtcp2_strerror(rv));
   rb_ivar_set(exc, rb_intern("@code"), INT2NUM(rv));
-  rb_exc_raise(exc);
+  return exc;
+}
+
+void
+quic_raise_ngtcp2_error(int rv)
+{
+  rb_exc_raise(quic_ngtcp2_error_new(rv));
 }
 
 RUBY_FUNC_EXPORTED void
@@ -96,7 +115,7 @@ Init_quic(void)
   rb_eQUICErrorRetry = rb_define_class_under(rb_eQUICError, "Retry", rb_eQUICError);
   rb_eQUICErrorClosed = rb_define_class_under(rb_eQUICError, "Closed", rb_eQUICError);
   rb_eQUICErrorCryptoError = rb_define_class_under(rb_eQUICError, "CryptoError", rb_eQUICError);
-  /* The TLS alert this client sent, when read_pkt fails in the handshake.
+  /* The TLS alert this endpoint sent, when read_pkt fails in the handshake.
      Alerts received from the peer are not recorded by ngtcp2. */
   rb_define_attr(rb_eQUICErrorCryptoError, "tls_alert", 1, 0);
   rb_eQUICErrorCertificateVerifyFailed =
@@ -120,7 +139,13 @@ Init_quic(void)
   rb_eQUICErrorStreamClosed = rb_define_class_under(rb_eQUICError, "StreamClosed", rb_eQUICError);
   rb_eQUICErrorStreamReset = rb_define_class_under(rb_eQUICError, "StreamReset", rb_eQUICError);
   rb_eQUICErrorNotBound = rb_define_class_under(rb_eQUICError, "NotBound", rb_eQUICError);
+  /* Raised by the QUIC::Stream methods of a connection whose streams a C
+     stream handler (quic/ext.h) owns. */
+  rb_eQUICErrorInvalidState = rb_define_class_under(rb_eQUICError, "InvalidState", rb_eQUICError);
 
+  Init_quic_tls_context(rb_mQUIC);
   Init_quic_connection_client(rb_mQUICConnection);
+  Init_quic_connection_server(rb_mQUICConnection);
+  Init_quic_endpoint(rb_mQUIC);
   Init_quic_stream(rb_mQUIC);
 }

data/ext/quic/quic.h

@@ -21,6 +21,7 @@
 extern VALUE rb_mQUIC;
 extern VALUE rb_mQUICConnection;
 extern VALUE rb_cQUICConnectionClient;
+extern VALUE rb_cQUICConnectionServer;
 
 extern VALUE rb_eQUICError;
 extern VALUE rb_eQUICErrorProto;
@@ -37,18 +38,17 @@ extern VALUE rb_eQUICErrorWaitWritable;
 extern VALUE rb_eQUICErrorStreamClosed;
 extern VALUE rb_eQUICErrorStreamReset;
 extern VALUE rb_eQUICErrorNotBound;
+extern VALUE rb_eQUICErrorInvalidState;
 
 void Init_quic_connection_client(VALUE rb_mQUICConnection);
+void Init_quic_connection_server(VALUE rb_mQUICConnection);
+void Init_quic_endpoint(VALUE rb_mQUIC);
 
-/* Accessor used by stream.c to issue ngtcp2 calls (e.g.
-   ngtcp2_conn_shutdown_stream_read) for streams that hold a back-reference
-   to their parent QUIC::Connection::Client via @client. Returns the raw
-   ngtcp2_conn pointer; the caller is responsible for ensuring the Ruby
-   Client object is alive for the duration of the call. */
-ngtcp2_conn *quic_client_conn(VALUE client);
+/* A QUIC::Error subclass instance mapped from an ngtcp2 negative error code,
+   with the code in #code. Made, not raised. */
+VALUE quic_ngtcp2_error_new(int rv);
 
-/* Raise a QUIC::Error subclass mapped from an ngtcp2 negative error code.
-   Never returns. */
+/* Raise quic_ngtcp2_error_new(rv). Never returns. */
 NORETURN(void quic_raise_ngtcp2_error(int rv));
 
 #endif /* QUIC_H */

data/ext/quic/stream.c

@@ -1,4 +1,5 @@
 #include "stream.h"
+#include "connection_common.h"
 
 #include <string.h>
 
@@ -33,7 +34,7 @@ quic_stream_alloc(VALUE klass)
 }
 
 VALUE
-quic_stream_new(int64_t stream_id, VALUE client)
+quic_stream_new(int64_t stream_id, VALUE owner)
 {
   VALUE self = quic_stream_alloc(rb_cQUICStream);
   quic_stream_t *s;
@@ -41,7 +42,7 @@ quic_stream_new(int64_t stream_id, VALUE client)
   s->stream_id = stream_id;
 
   rb_ivar_set(self, rb_intern("@id"), LL2NUM(stream_id));
-  rb_ivar_set(self, rb_intern("@client"), client);
+  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));
@@ -96,22 +97,35 @@ quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data)
   return RTEST(fin);
 }
 
-/* Return the effective send window for this stream, capped by both the
-   per-stream and the per-connection flow control limits ngtcp2 tracks. */
+/* 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. */
 static uint64_t
-quic_stream_window_left(VALUE client_v, quic_stream_t *s)
+quic_stream_window_left(VALUE self, VALUE client_v, quic_stream_t *s)
 {
-  ngtcp2_conn *conn = quic_client_conn(client_v);
-  uint64_t stream_left = ngtcp2_conn_get_max_stream_data_left(conn, s->stream_id);
-  uint64_t conn_left = ngtcp2_conn_get_max_data_left(conn);
-  return stream_left < conn_left ? stream_left : conn_left;
+  ngtcp2_conn *conn = quic_conn_ptr(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));
+  }
+  uint64_t unsent = queued_end - s->sent_offset;
+  return left > unsent ? left - unsent : 0;
 }
 
-/* Blocking write: block by repeatedly invoking Client#pump_once 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. */
+/* 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. */
 static VALUE
 quic_stream_write_m(int argc, VALUE *argv, VALUE self)
 {
@@ -132,9 +146,9 @@ quic_stream_write_m(int argc, VALUE *argv, VALUE self)
     quic_stream_t *s;
     TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
     /* Loop until the full payload would fit in the current window. pump_once
-       raises QUIC::Error::NotBound if @client has no socket bound; that
-       error surfaces verbatim. */
-    while ((uint64_t)needed > quic_stream_window_left(client_v, s)) {
+       raises QUIC::Error::NotBound if the connection has not been #bind'ed;
+       that error surfaces verbatim. */
+    while ((uint64_t)needed > quic_stream_window_left(self, client_v, s)) {
       rb_funcall(client_v, rb_intern("pump_once"), 0);
     }
   }
@@ -169,7 +183,7 @@ 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);
-  uint64_t avail = quic_stream_window_left(client_v, s);
+  uint64_t avail = quic_stream_window_left(self, client_v, s);
 
   if (avail == 0) {
     rb_raise(rb_eQUICErrorWaitWritable, "stream send window is full");
@@ -231,6 +245,19 @@ quic_stream_read_nonblock_m(VALUE self, VALUE length_v)
   }
   rb_str_set_len(buffer, have - take);
 
+  /* The application has consumed |take| bytes, so give the peer that much
+     more stream and connection credit. Without this the peer stops sending
+     once initial_max_data / initial_max_stream_data are used up. A stream
+     ngtcp2 has already forgotten is ignored (the call returns 0), but the
+     connection window still grows. Bare Streams have no connection. */
+  VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
+  if (!NIL_P(client_v)) {
+    ngtcp2_conn *conn = quic_conn_ptr(client_v);
+    int rv = ngtcp2_conn_extend_max_stream_offset(conn, s->stream_id, (uint64_t)take);
+    if (rv != 0) quic_raise_ngtcp2_error(rv);
+    ngtcp2_conn_extend_max_offset(conn, (uint64_t)take);
+  }
+
   return out;
 }
 
@@ -243,6 +270,19 @@ quic_stream_eof_p(VALUE self)
   return (RSTRING_LEN(buffer) == 0 && s->fin_received) ? Qtrue : Qfalse;
 }
 
+/* True once the stream is fully closed: both directions have finished (FIN
+   or reset) and everything sent has been acknowledged. Stays false if the
+   connection closes first, since ngtcp2 does not report stream closure then.
+   Keeps returning true after the stream has left the connection's @streams.
+   A bare Stream is never closed. */
+static VALUE
+quic_stream_closed_p(VALUE self)
+{
+  quic_stream_t *s;
+  TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
+  return s->closed ? Qtrue : Qfalse;
+}
+
 static VALUE
 quic_stream_close_read_m(VALUE self)
 {
@@ -250,7 +290,7 @@ quic_stream_close_read_m(VALUE self)
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
   VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
-  ngtcp2_conn *conn = quic_client_conn(client_v);
+  ngtcp2_conn *conn = quic_conn_ptr(client_v);
 
   /* ngtcp2_conn_shutdown_stream_read sends STOP_SENDING. app_error_code 0
      since no QUIC-level error API is exposed yet. */
@@ -296,13 +336,32 @@ quic_stream_reset_m(int argc, VALUE *argv, VALUE self)
     return Qnil;
   }
 
-  ngtcp2_conn *conn = quic_client_conn(client_v);
+  ngtcp2_conn *conn = quic_conn_ptr(client_v);
   int rv = ngtcp2_conn_shutdown_stream_write(conn, 0, s->stream_id, error_code);
   if (rv != 0) quic_raise_ngtcp2_error(rv);
   s->reset = true;
   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). */
+static VALUE
+quic_stream_accepted_m(VALUE self)
+{
+  quic_stream_t *s;
+  TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
+  s->accepted = true;
+  if (s->peer_stream_held) {
+    s->peer_stream_held = false;
+    VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
+    if (!NIL_P(client_v)) {
+      quic_conn_give_back_peer_stream(quic_conn_ptr(client_v), s->stream_id);
+    }
+  }
+  return Qnil;
+}
+
 void
 Init_quic_stream(VALUE rb_mQUICArg)
 {
@@ -313,8 +372,10 @@ Init_quic_stream(VALUE rb_mQUICArg)
   rb_define_method(rb_cQUICStream, "close_write", quic_stream_close_write_m, 0);
   rb_define_method(rb_cQUICStream, "read_nonblock", quic_stream_read_nonblock_m, 1);
   rb_define_method(rb_cQUICStream, "eof?", quic_stream_eof_p, 0);
+  rb_define_method(rb_cQUICStream, "closed?", quic_stream_closed_p, 0);
   rb_define_method(rb_cQUICStream, "close_read", quic_stream_close_read_m, 0);
   rb_define_method(rb_cQUICStream, "close", quic_stream_close_m, 0);
   rb_define_method(rb_cQUICStream, "reset", quic_stream_reset_m, -1);
+  rb_define_private_method(rb_cQUICStream, "_accepted", quic_stream_accepted_m, 0);
   /* #read (blocking) and #initiator are defined in lib/quic/stream.rb. */
 }

data/ext/quic/stream.h

@@ -7,7 +7,7 @@ extern VALUE rb_cQUICStream;
 
 void Init_quic_stream(VALUE rb_mQUICArg);
 
-/* Internal helpers used by connection_client.c stream callbacks and
+/* Internal helpers used by connection_common.c stream callbacks and
    write_pkt's stream-aware path. */
 
 typedef struct {
@@ -29,17 +29,23 @@ typedef struct {
   bool closed;                /* stream_close callback fired */
   uint64_t close_app_error_code;
   bool close_has_app_error_code;
-  /* Set once a peer-initiated (server) stream has been pushed onto the
-     owner Client's @accept_queue, so recv_stream_data does not enqueue it
+  /* 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. */
   bool accept_queued;
+  /* Set once #accept_stream has handed the stream to the application. */
+  bool accepted;
+  /* The stream closed while it waited in @accept_queue: the peer gets the
+     stream it used up back when the stream is accepted. */
+  bool peer_stream_held;
 } quic_stream_t;
 
 extern const rb_data_type_t quic_stream_data_type;
 
-/* Allocate a new QUIC::Stream Ruby object with a zero-initialized
-   quic_stream_t. Caller fills stream_id and ivars (@id / @client /
-   @pending_chunks / @recv_buffer). */
-VALUE quic_stream_new(int64_t stream_id, VALUE client);
+/* Allocate a new QUIC::Stream Ruby object for stream_id with a
+   zero-initialized quic_stream_t, and set its ivars (@id / @client /
+   @pending_chunks / @recv_buffer). @client is owner, the Client or Server
+   the stream belongs to; the ivar keeps its name for both. */
+VALUE quic_stream_new(int64_t stream_id, VALUE owner);
 
 #endif /* QUIC_STREAM_H */