quic 0.0.5 → 0.0.7

data/ext/quic/connection_common.h

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

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

data/ext/quic/extconf.rb

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

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

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