quic 0.0.1 → 0.0.3

data/ext/quic/quic.c

@@ -1,24 +1,38 @@
 #include "quic.h"
 #include "stream.h"
+#include "connection_common.h"
 
-VALUE rb_mQuic;
-VALUE rb_mQuicConnection;
-VALUE rb_cQuicConnectionClient;
+VALUE rb_mQUIC;
+VALUE rb_mQUICConnection;
+VALUE rb_cQUICConnectionClient;
+VALUE rb_cQUICConnectionServer;
 
-VALUE rb_eQuicError;
-VALUE rb_eQuicErrorProto;
-VALUE rb_eQuicErrorDropConn;
-VALUE rb_eQuicErrorRetry;
-VALUE rb_eQuicErrorClosed;
-VALUE rb_eQuicErrorCryptoError;
-VALUE rb_eQuicErrorHandshakeTimeout;
-VALUE rb_eQuicErrorFlowControl;
-VALUE rb_eQuicErrorUnknown;
-VALUE rb_eQuicErrorWaitReadable;
-VALUE rb_eQuicErrorWaitWritable;
-VALUE rb_eQuicErrorStreamClosed;
-VALUE rb_eQuicErrorStreamReset;
-VALUE rb_eQuicErrorNotBound;
+VALUE rb_eQUICError;
+VALUE rb_eQUICErrorProto;
+VALUE rb_eQUICErrorDropConn;
+VALUE rb_eQUICErrorRetry;
+VALUE rb_eQUICErrorClosed;
+VALUE rb_eQUICErrorCryptoError;
+VALUE rb_eQUICErrorCertificateVerifyFailed;
+VALUE rb_eQUICErrorHandshakeTimeout;
+VALUE rb_eQUICErrorFlowControl;
+VALUE rb_eQUICErrorUnknown;
+VALUE rb_eQUICErrorWaitReadable;
+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)
@@ -29,86 +43,109 @@ quic_library_versions(VALUE self)
                rb_str_new_cstr(ngtcp2_version(0)->version_str));
   rb_hash_aset(h, ID2SYM(rb_intern("openssl")),
                rb_str_new_cstr(OpenSSL_version(OPENSSL_VERSION)));
+  /* picotls has neither a version macro nor releases, so report the commit
+     extconf.rb built against (passed in as -DQUIC_PICOTLS_COMMIT). */
+  rb_hash_aset(h, ID2SYM(rb_intern("picotls")),
+               rb_str_new_cstr(QUIC_PICOTLS_COMMIT));
   return h;
 }
 
-void
-quic_raise_ngtcp2_error(int rv)
+VALUE
+quic_ngtcp2_error_new(int rv)
 {
   VALUE cls;
   switch (rv) {
     case NGTCP2_ERR_PROTO:
-      cls = rb_eQuicErrorProto;
+      cls = rb_eQUICErrorProto;
       break;
     case NGTCP2_ERR_DROP_CONN:
-      cls = rb_eQuicErrorDropConn;
+      cls = rb_eQUICErrorDropConn;
       break;
     case NGTCP2_ERR_RETRY:
-      cls = rb_eQuicErrorRetry;
+      cls = rb_eQUICErrorRetry;
       break;
     case NGTCP2_ERR_CLOSING:
     case NGTCP2_ERR_DRAINING:
-      cls = rb_eQuicErrorClosed;
+      cls = rb_eQUICErrorClosed;
       break;
     case NGTCP2_ERR_IDLE_CLOSE:
-      cls = rb_eQuicErrorClosed;
+      cls = rb_eQUICErrorClosed;
       break;
     case NGTCP2_ERR_CRYPTO:
-      cls = rb_eQuicErrorCryptoError;
+      cls = rb_eQUICErrorCryptoError;
       break;
     case NGTCP2_ERR_HANDSHAKE_TIMEOUT:
-      cls = rb_eQuicErrorHandshakeTimeout;
+      cls = rb_eQUICErrorHandshakeTimeout;
       break;
     case NGTCP2_ERR_STREAM_DATA_BLOCKED:
-      cls = rb_eQuicErrorFlowControl;
+      cls = rb_eQUICErrorFlowControl;
       break;
     case NGTCP2_ERR_STREAM_SHUT_WR:
-      cls = rb_eQuicErrorStreamClosed;
+      cls = rb_eQUICErrorStreamClosed;
       break;
     default:
-      cls = rb_eQuicErrorUnknown;
+      cls = rb_eQUICErrorUnknown;
       break;
   }
 
   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
 Init_quic(void)
 {
-  rb_mQuic = rb_define_module("Quic");
-  rb_mQuicConnection = rb_define_module_under(rb_mQuic, "Connection");
-  rb_define_singleton_method(rb_mQuic, "library_versions", quic_library_versions, 0);
+  rb_mQUIC = rb_define_module("QUIC");
+  rb_mQUICConnection = rb_define_module_under(rb_mQUIC, "Connection");
+  rb_define_singleton_method(rb_mQUIC, "library_versions", quic_library_versions, 0);
 
-  /* Quic::Error is defined in Ruby (lib/quic.rb) before this Init_quic runs,
+  /* QUIC::Error is defined in Ruby (lib/quic.rb) before this Init_quic runs,
      so rb_const_get retrieves the already-defined base class. Subclasses live
-     under Quic::Error::<Name>. */
-  rb_eQuicError = rb_const_get(rb_mQuic, rb_intern("Error"));
-  rb_eQuicErrorProto = rb_define_class_under(rb_eQuicError, "Proto", rb_eQuicError);
-  rb_eQuicErrorDropConn = rb_define_class_under(rb_eQuicError, "DropConn", rb_eQuicError);
-  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);
-  rb_eQuicErrorHandshakeTimeout = rb_define_class_under(rb_eQuicError, "HandshakeTimeout", rb_eQuicError);
-  rb_eQuicErrorFlowControl = rb_define_class_under(rb_eQuicError, "FlowControl", rb_eQuicError);
-  rb_eQuicErrorUnknown = rb_define_class_under(rb_eQuicError, "Unknown", rb_eQuicError);
+     under QUIC::Error::<Name>. */
+  rb_eQUICError = rb_const_get(rb_mQUIC, rb_intern("Error"));
+  rb_eQUICErrorProto = rb_define_class_under(rb_eQUICError, "Proto", rb_eQUICError);
+  rb_eQUICErrorDropConn = rb_define_class_under(rb_eQUICError, "DropConn", rb_eQUICError);
+  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 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 =
+    rb_define_class_under(rb_eQUICError, "CertificateVerifyFailed", rb_eQUICErrorCryptoError);
+  /* X509_V_ERR_* from the chain / name check, or nil when no certificate came. */
+  rb_define_attr(rb_eQUICErrorCertificateVerifyFailed, "verify_result", 1, 0);
+  rb_eQUICErrorHandshakeTimeout = rb_define_class_under(rb_eQUICError, "HandshakeTimeout", rb_eQUICError);
+  rb_eQUICErrorFlowControl = rb_define_class_under(rb_eQUICError, "FlowControl", rb_eQUICError);
+  rb_eQUICErrorUnknown = rb_define_class_under(rb_eQUICError, "Unknown", rb_eQUICError);
 
   /* IO-style non-blocking errors. Mix in the standard IO::Wait{Readable,Writable}
-     modules so callers can `rescue IO::WaitReadable` (or the Quic subclass)
+     modules so callers can `rescue IO::WaitReadable` (or the QUIC subclass)
      interchangeably with stdlib IO objects. */
   VALUE io_wait_readable = rb_const_get(rb_cIO, rb_intern("WaitReadable"));
   VALUE io_wait_writable = rb_const_get(rb_cIO, rb_intern("WaitWritable"));
-  rb_eQuicErrorWaitReadable = rb_define_class_under(rb_eQuicError, "WaitReadable", rb_eQuicError);
-  rb_include_module(rb_eQuicErrorWaitReadable, io_wait_readable);
-  rb_eQuicErrorWaitWritable = rb_define_class_under(rb_eQuicError, "WaitWritable", rb_eQuicError);
-  rb_include_module(rb_eQuicErrorWaitWritable, io_wait_writable);
+  rb_eQUICErrorWaitReadable = rb_define_class_under(rb_eQUICError, "WaitReadable", rb_eQUICError);
+  rb_include_module(rb_eQUICErrorWaitReadable, io_wait_readable);
+  rb_eQUICErrorWaitWritable = rb_define_class_under(rb_eQUICError, "WaitWritable", rb_eQUICError);
+  rb_include_module(rb_eQUICErrorWaitWritable, io_wait_writable);
 
-  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);
+  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_connection_client(rb_mQuicConnection);
-  Init_quic_stream(rb_mQuic);
+  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

@@ -6,39 +6,49 @@
 
 #include <ngtcp2/ngtcp2.h>
 #include <ngtcp2/ngtcp2_crypto.h>
-#include <ngtcp2/ngtcp2_crypto_quictls.h>
-#include <openssl/ssl.h>
-
-extern VALUE rb_mQuic;
-extern VALUE rb_mQuicConnection;
-extern VALUE rb_cQuicConnectionClient;
-
-extern VALUE rb_eQuicError;
-extern VALUE rb_eQuicErrorProto;
-extern VALUE rb_eQuicErrorDropConn;
-extern VALUE rb_eQuicErrorRetry;
-extern VALUE rb_eQuicErrorClosed;
-extern VALUE rb_eQuicErrorCryptoError;
-extern VALUE rb_eQuicErrorHandshakeTimeout;
-extern VALUE rb_eQuicErrorFlowControl;
-extern VALUE rb_eQuicErrorUnknown;
-extern VALUE rb_eQuicErrorWaitReadable;
-extern VALUE rb_eQuicErrorWaitWritable;
-extern VALUE rb_eQuicErrorStreamClosed;
-extern VALUE rb_eQuicErrorStreamReset;
-extern VALUE rb_eQuicErrorNotBound;
-
-void Init_quic_connection_client(VALUE rb_mQuicConnection);
-
-/* 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);
-
-/* Raise a Quic::Error subclass mapped from an ngtcp2 negative error code.
-   Never returns. */
+#include <picotls.h>
+#include <picotls/openssl.h>
+#include <ngtcp2/ngtcp2_crypto_picotls.h>
+#include <openssl/crypto.h>
+
+/* picotls disables ptls_openssl_x25519 unless it is built with the patch in
+   ext/quic/patches/picotls/. extconf.rb checks the same condition at configure
+   time; this catches a prebuilt ports/ tree whose patch was swapped out. */
+#if !PTLS_OPENSSL_HAVE_X25519
+#error "picotls was built without X25519; is ext/quic/patches/picotls/*.patch applied?"
+#endif
+
+extern VALUE rb_mQUIC;
+extern VALUE rb_mQUICConnection;
+extern VALUE rb_cQUICConnectionClient;
+extern VALUE rb_cQUICConnectionServer;
+
+extern VALUE rb_eQUICError;
+extern VALUE rb_eQUICErrorProto;
+extern VALUE rb_eQUICErrorDropConn;
+extern VALUE rb_eQUICErrorRetry;
+extern VALUE rb_eQUICErrorClosed;
+extern VALUE rb_eQUICErrorCryptoError;
+extern VALUE rb_eQUICErrorCertificateVerifyFailed;
+extern VALUE rb_eQUICErrorHandshakeTimeout;
+extern VALUE rb_eQUICErrorFlowControl;
+extern VALUE rb_eQUICErrorUnknown;
+extern VALUE rb_eQUICErrorWaitReadable;
+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);
+
+/* 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 quic_ngtcp2_error_new(rv). Never returns. */
 NORETURN(void quic_raise_ngtcp2_error(int rv));
 
 #endif /* QUIC_H */

data/ext/quic/stream.c

@@ -1,8 +1,9 @@
 #include "stream.h"
+#include "connection_common.h"
 
 #include <string.h>
 
-VALUE rb_cQuicStream;
+VALUE rb_cQUICStream;
 
 static void
 quic_stream_free(void *ptr)
@@ -18,7 +19,7 @@ quic_stream_size(const void *ptr)
 }
 
 const rb_data_type_t quic_stream_data_type = {
-  "Quic::Stream",
+  "QUIC::Stream",
   {NULL, quic_stream_free, quic_stream_size,},
   NULL, NULL,
   RUBY_TYPED_FREE_IMMEDIATELY,
@@ -33,15 +34,15 @@ 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);
+  VALUE self = quic_stream_alloc(rb_cQUICStream);
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
   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));
@@ -53,7 +54,7 @@ quic_stream_new(int64_t stream_id, VALUE client)
    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. */
+   never raises QUIC::Error::WaitWritable on its own. */
 static VALUE
 quic_stream_enqueue(VALUE self, VALUE data, bool fin)
 {
@@ -61,10 +62,10 @@ quic_stream_enqueue(VALUE self, VALUE data, bool fin)
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
   if (s->reset || s->closed) {
-    rb_raise(rb_eQuicErrorStreamClosed, "stream is closed");
+    rb_raise(rb_eQUICErrorStreamClosed, "stream is closed");
   }
   if (s->fin_sent) {
-    rb_raise(rb_eQuicErrorStreamClosed, "stream FIN already sent");
+    rb_raise(rb_eQUICErrorStreamClosed, "stream FIN already sent");
   }
 
   Check_Type(data, T_STRING);
@@ -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);
     }
   }
@@ -143,7 +157,7 @@ quic_stream_write_m(int argc, VALUE *argv, VALUE self)
 }
 
 /* Non-blocking write: enqueue at most `window_left` bytes from `data` and
-   return the count actually queued. Raises Quic::Error::WaitWritable if the
+   return the count actually queued. Raises QUIC::Error::WaitWritable if the
    window is zero and we have a non-empty payload to send. If only a partial
    prefix fits, FIN is NOT set on this call (caller re-issues with
    `fin: true` once the remainder is accepted) so we don't half-commit FIN.
@@ -169,10 +183,10 @@ 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");
+    rb_raise(rb_eQUICErrorWaitWritable, "stream send window is full");
   }
 
   long take = ((uint64_t)needed <= avail) ? needed : (long)avail;
@@ -198,7 +212,7 @@ quic_stream_close_write_m(VALUE self)
    to drop the returned prefix.
 
    - buffer empty + fin_received: raise EOFError (IO#read_nonblock semantics)
-   - buffer empty + !fin_received: raise Quic::Error::WaitReadable
+   - buffer empty + !fin_received: raise QUIC::Error::WaitReadable
    - buffer non-empty: return min(length, buffer.bytesize) bytes
 */
 static VALUE
@@ -218,7 +232,7 @@ quic_stream_read_nonblock_m(VALUE self, VALUE length_v)
     if (s->fin_received) {
       rb_raise(rb_eEOFError, "end of file reached");
     }
-    rb_raise(rb_eQuicErrorWaitReadable, "no data available");
+    rb_raise(rb_eQUICErrorWaitReadable, "no data available");
   }
 
   long take = (length < have) ? length : have;
@@ -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,10 +290,10 @@ 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. */
+     since no QUIC-level error API is exposed yet. */
   int rv = ngtcp2_conn_shutdown_stream_read(conn, 0, s->stream_id, 0);
   if (rv != 0) quic_raise_ngtcp2_error(rv);
   return Qnil;
@@ -268,17 +308,74 @@ quic_stream_close_m(VALUE self)
   return Qnil;
 }
 
+/* Abort the send side of the stream with RESET_STREAM
+   (ngtcp2_conn_shutdown_stream_write), carrying the given application error
+   code (default 0). After #reset, #write / #write_nonblock raise
+   QUIC::Error::StreamClosed because quic_stream_enqueue rejects a stream
+   with s->reset set. The read side is untouched (use #close_read /
+   #close for STOP_SENDING). Idempotent: a second #reset is a no-op.
+
+   A bare Stream (@client == nil, used by unit-test fixtures) skips the
+   ngtcp2 call and only flips s->reset, mirroring the #write / #close_write
+   bare-Stream escapes. */
+static VALUE
+quic_stream_reset_m(int argc, VALUE *argv, VALUE self)
+{
+  VALUE error_code_v = Qnil;
+  rb_scan_args(argc, argv, "01", &error_code_v);
+  uint64_t error_code = NIL_P(error_code_v) ? 0 : NUM2ULL(error_code_v);
+
+  quic_stream_t *s;
+  TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
+
+  if (s->reset) return Qnil;  /* idempotent */
+
+  VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
+  if (NIL_P(client_v)) {
+    s->reset = true;  /* bare Stream escape */
+    return Qnil;
+  }
+
+  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)
+Init_quic_stream(VALUE rb_mQUICArg)
 {
-  rb_cQuicStream = rb_define_class_under(rb_mQuicArg, "Stream", rb_cObject);
-  rb_define_alloc_func(rb_cQuicStream, quic_stream_alloc);
-  rb_define_method(rb_cQuicStream, "write", quic_stream_write_m, -1);
-  rb_define_method(rb_cQuicStream, "write_nonblock", quic_stream_write_nonblock_m, -1);
-  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, "close_read", quic_stream_close_read_m, 0);
-  rb_define_method(rb_cQuicStream, "close", quic_stream_close_m, 0);
+  rb_cQUICStream = rb_define_class_under(rb_mQUICArg, "Stream", rb_cObject);
+  rb_define_alloc_func(rb_cQUICStream, quic_stream_alloc);
+  rb_define_method(rb_cQUICStream, "write", quic_stream_write_m, -1);
+  rb_define_method(rb_cQUICStream, "write_nonblock", quic_stream_write_nonblock_m, -1);
+  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

@@ -3,11 +3,11 @@
 
 #include "quic.h"
 
-extern VALUE rb_cQuicStream;
+extern VALUE rb_cQUICStream;
 
-void Init_quic_stream(VALUE rb_mQuicArg);
+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,13 +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 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 */