quic 0.0.3 → 0.0.4

data/ext/quic/endpoint.h

@@ -10,19 +10,22 @@ extern VALUE rb_cQUICEndpoint;
    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);
+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);
+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);
+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

@@ -4,16 +4,12 @@
    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)
-{
+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)
-{
+static quic_ext_conn *quic_ext_conn_get(VALUE conn) {
   return (quic_ext_conn *)rb_check_typeddata(conn, &quic_conn_data_type);
 }
 
@@ -22,15 +18,17 @@ quic_ext_conn_get(VALUE conn)
    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)
-{
+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;
+  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;
+  if (RB_TYPE_P(streams, T_HASH) && RHASH_SIZE(streams) > 0)
+    return QUIC_EXT_ERR_INVALID_STATE;
 
   c->handler = h;
   c->handler_ud = ud;
@@ -39,58 +37,54 @@ quic_ext_set_stream_handler(quic_ext_conn *ec, const quic_ext_stream_handler *h,
   return 0;
 }
 
-static int
-quic_ext_open_uni_stream(quic_ext_conn *ec, int64_t *id)
-{
+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;
+  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)
-{
+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;
+  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)
-{
+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;
+             ? 0
+             : QUIC_EXT_ERR_OTHER;
 }
 
-static int
-quic_ext_shutdown_stream_write(quic_ext_conn *ec, int64_t id, uint64_t app_error_code)
-{
+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;
+             ? 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)
-{
+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;
+  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)
-{
+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;
@@ -98,15 +92,15 @@ quic_ext_set_application_error(quic_ext_conn *ec, uint64_t app_error_code)
 }
 
 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,
+    .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/include/quic/ext.h

@@ -4,8 +4,8 @@
  * 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");
+ *   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:
@@ -32,26 +32,29 @@
 #ifndef QUIC_EXT_H
 #define QUIC_EXT_H 1
 
+#include <ruby.h>
 #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_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)
+#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 {
+  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 */
+  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 (*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);
@@ -59,22 +62,26 @@ typedef struct {
   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 (*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 */
+  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);
+  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;

data/ext/quic/quic.c

@@ -1,6 +1,6 @@
 #include "quic.h"
-#include "stream.h"
 #include "connection_common.h"
+#include "stream.h"
 
 VALUE rb_mQUIC;
 VALUE rb_mQUICConnection;
@@ -28,15 +28,11 @@ VALUE rb_eQUICErrorInvalidState;
    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)
-{
+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)
-{
+static VALUE quic_library_versions(VALUE self) {
   (void)self;
   VALUE h = rb_hash_new();
   rb_hash_aset(h, ID2SYM(rb_intern("ngtcp2")),
@@ -51,41 +47,40 @@ quic_library_versions(VALUE self)
 }
 
 VALUE
-quic_ngtcp2_error_new(int rv)
-{
+quic_ngtcp2_error_new(int rv) {
   VALUE cls;
   switch (rv) {
-    case NGTCP2_ERR_PROTO:
-      cls = rb_eQUICErrorProto;
-      break;
-    case NGTCP2_ERR_DROP_CONN:
-      cls = rb_eQUICErrorDropConn;
-      break;
-    case NGTCP2_ERR_RETRY:
-      cls = rb_eQUICErrorRetry;
-      break;
-    case NGTCP2_ERR_CLOSING:
-    case NGTCP2_ERR_DRAINING:
-      cls = rb_eQUICErrorClosed;
-      break;
-    case NGTCP2_ERR_IDLE_CLOSE:
-      cls = rb_eQUICErrorClosed;
-      break;
-    case NGTCP2_ERR_CRYPTO:
-      cls = rb_eQUICErrorCryptoError;
-      break;
-    case NGTCP2_ERR_HANDSHAKE_TIMEOUT:
-      cls = rb_eQUICErrorHandshakeTimeout;
-      break;
-    case NGTCP2_ERR_STREAM_DATA_BLOCKED:
-      cls = rb_eQUICErrorFlowControl;
-      break;
-    case NGTCP2_ERR_STREAM_SHUT_WR:
-      cls = rb_eQUICErrorStreamClosed;
-      break;
-    default:
-      cls = rb_eQUICErrorUnknown;
-      break;
+  case NGTCP2_ERR_PROTO:
+    cls = rb_eQUICErrorProto;
+    break;
+  case NGTCP2_ERR_DROP_CONN:
+    cls = rb_eQUICErrorDropConn;
+    break;
+  case NGTCP2_ERR_RETRY:
+    cls = rb_eQUICErrorRetry;
+    break;
+  case NGTCP2_ERR_CLOSING:
+  case NGTCP2_ERR_DRAINING:
+    cls = rb_eQUICErrorClosed;
+    break;
+  case NGTCP2_ERR_IDLE_CLOSE:
+    cls = rb_eQUICErrorClosed;
+    break;
+  case NGTCP2_ERR_CRYPTO:
+    cls = rb_eQUICErrorCryptoError;
+    break;
+  case NGTCP2_ERR_HANDSHAKE_TIMEOUT:
+    cls = rb_eQUICErrorHandshakeTimeout;
+    break;
+  case NGTCP2_ERR_STREAM_DATA_BLOCKED:
+    cls = rb_eQUICErrorFlowControl;
+    break;
+  case NGTCP2_ERR_STREAM_SHUT_WR:
+    cls = rb_eQUICErrorStreamClosed;
+    break;
+  default:
+    cls = rb_eQUICErrorUnknown;
+    break;
   }
 
   VALUE exc = rb_exc_new_cstr(cls, ngtcp2_strerror(rv));
@@ -93,55 +88,68 @@ quic_ngtcp2_error_new(int rv)
   return exc;
 }
 
-void
-quic_raise_ngtcp2_error(int rv)
-{
+void quic_raise_ngtcp2_error(int rv) {
   rb_exc_raise(quic_ngtcp2_error_new(rv));
 }
 
-RUBY_FUNC_EXPORTED void
-Init_quic(void)
-{
+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_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,
      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_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_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);
+  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)
-     interchangeably with stdlib IO objects. */
+  /* IO-style non-blocking errors. Mix in the standard
+     IO::Wait{Readable,Writable} 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_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_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);
+  rb_eQUICErrorInvalidState =
+      rb_define_class_under(rb_eQUICError, "InvalidState", rb_eQUICError);
 
   Init_quic_tls_context(rb_mQUIC);
   Init_quic_connection_client(rb_mQUICConnection);

data/ext/quic/quic.h

@@ -6,16 +6,18 @@
 
 #include <ngtcp2/ngtcp2.h>
 #include <ngtcp2/ngtcp2_crypto.h>
-#include <picotls.h>
-#include <picotls/openssl.h>
 #include <ngtcp2/ngtcp2_crypto_picotls.h>
 #include <openssl/crypto.h>
+#include <picotls.h>
+#include <picotls/openssl.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
+/* clang-format off */
 #error "picotls was built without X25519; is ext/quic/patches/picotls/*.patch applied?"
+/* clang-format on */
 #endif
 
 extern VALUE rb_mQUIC;