quic 0.0.3 → 0.0.5

data/ext/quic/stream.c

@@ -5,37 +5,33 @@
 
 VALUE rb_cQUICStream;
 
-static void
-quic_stream_free(void *ptr)
-{
-  xfree(ptr);
-}
+static void quic_stream_free(void *ptr) { xfree(ptr); }
 
-static size_t
-quic_stream_size(const void *ptr)
-{
+static size_t quic_stream_size(const void *ptr) {
   (void)ptr;
   return sizeof(quic_stream_t);
 }
 
 const rb_data_type_t quic_stream_data_type = {
-  "QUIC::Stream",
-  {NULL, quic_stream_free, quic_stream_size,},
-  NULL, NULL,
-  RUBY_TYPED_FREE_IMMEDIATELY,
+    "QUIC::Stream",
+    {
+        NULL,
+        quic_stream_free,
+        quic_stream_size,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static VALUE
-quic_stream_alloc(VALUE klass)
-{
+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
-quic_stream_new(int64_t stream_id, VALUE owner)
-{
+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);
@@ -49,21 +45,30 @@ quic_stream_new(int64_t stream_id, VALUE owner)
   return self;
 }
 
+/* Raise QUIC::Error::StreamClosed if nothing more can be written to the
+   stream: it was reset or has closed, or the peer sent STOP_SENDING. */
+static void quic_stream_check_writable(quic_stream_t *s) {
+  if (s->reset || s->closed) {
+    rb_raise(rb_eQUICErrorStreamClosed, "stream is closed");
+  }
+  if (s->stopped) {
+    rb_raise(rb_eQUICErrorStreamClosed,
+             "the peer asked to stop sending (error code %llu)",
+             (unsigned long long)s->stop_app_error_code);
+  }
+}
+
 /* 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
    never raises QUIC::Error::WaitWritable on its own. */
-static VALUE
-quic_stream_enqueue(VALUE self, VALUE data, bool fin)
-{
+static VALUE quic_stream_enqueue(VALUE self, VALUE data, bool fin) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
-  if (s->reset || s->closed) {
-    rb_raise(rb_eQUICErrorStreamClosed, "stream is closed");
-  }
+  quic_stream_check_writable(s);
   if (s->fin_sent) {
     rb_raise(rb_eQUICErrorStreamClosed, "stream FIN already sent");
   }
@@ -87,12 +92,11 @@ quic_stream_enqueue(VALUE self, VALUE data, bool fin)
   return LONG2NUM(len);
 }
 
-static bool
-quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data)
-{
+static bool quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data) {
   VALUE opts = Qnil;
   rb_scan_args(argc, argv, "1:", data, &opts);
-  if (NIL_P(opts)) return false;
+  if (NIL_P(opts))
+    return false;
   VALUE fin = rb_hash_lookup(opts, ID2SYM(rb_intern("fin")));
   return RTEST(fin);
 }
@@ -101,12 +105,14 @@ quic_stream_fin_kwarg(int argc, VALUE *argv, VALUE *data)
    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 self, VALUE client_v, quic_stream_t *s)
-{
+   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);
-  uint64_t stream_left = ngtcp2_conn_get_max_stream_data_left2(conn, s->stream_id);
+  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;
 
@@ -124,17 +130,17 @@ quic_stream_window_left(VALUE self, VALUE client_v, quic_stream_t *s)
 /* 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)
-{
+   of `data`. A window that can no longer open, because the peer sent
+   STOP_SENDING or the stream ended meanwhile, raises
+   QUIC::Error::StreamClosed. 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) {
   VALUE data;
   bool fin = quic_stream_fin_kwarg(argc, argv, &data);
 
   VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
   if (NIL_P(client_v)) {
-    return quic_stream_enqueue(self, data, fin);  /* bare-Stream test escape */
+    return quic_stream_enqueue(self, data, fin); /* bare-Stream test escape */
   }
 
   /* These will be re-validated by quic_stream_enqueue, but we need the
@@ -148,8 +154,10 @@ quic_stream_write_m(int argc, VALUE *argv, VALUE self)
     /* Loop until the full payload would fit in the current window. pump_once
        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)) {
       rb_funcall(client_v, rb_intern("pump_once"), 0);
+      quic_stream_check_writable(s);
     }
   }
 
@@ -162,15 +170,13 @@ quic_stream_write_m(int argc, VALUE *argv, VALUE self)
    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.
    Bare Streams with @client = nil skip the window check entirely. */
-static VALUE
-quic_stream_write_nonblock_m(int argc, VALUE *argv, VALUE self)
-{
+static VALUE quic_stream_write_nonblock_m(int argc, VALUE *argv, VALUE self) {
   VALUE data;
   bool fin = quic_stream_fin_kwarg(argc, argv, &data);
 
   VALUE client_v = rb_ivar_get(self, rb_intern("@client"));
   if (NIL_P(client_v)) {
-    return quic_stream_enqueue(self, data, fin);  /* bare-Stream test escape */
+    return quic_stream_enqueue(self, data, fin); /* bare-Stream test escape */
   }
 
   Check_Type(data, T_STRING);
@@ -183,6 +189,8 @@ 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);
+  /* 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);
 
   if (avail == 0) {
@@ -195,12 +203,11 @@ quic_stream_write_nonblock_m(int argc, VALUE *argv, VALUE self)
   return quic_stream_enqueue(self, slice, effective_fin);
 }
 
-static VALUE
-quic_stream_close_write_m(VALUE self)
-{
+static VALUE quic_stream_close_write_m(VALUE self) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
-  if (s->fin_sent) return Qnil;  /* idempotent */
+  if (s->fin_sent)
+    return Qnil; /* idempotent */
   VALUE empty = rb_str_new("", 0);
   rb_enc_associate_index(empty, rb_ascii8bit_encindex());
   quic_stream_enqueue(self, empty, true);
@@ -215,9 +222,7 @@ quic_stream_close_write_m(VALUE self)
    - buffer empty + !fin_received: raise QUIC::Error::WaitReadable
    - buffer non-empty: return min(length, buffer.bytesize) bytes
 */
-static VALUE
-quic_stream_read_nonblock_m(VALUE self, VALUE length_v)
-{
+static VALUE quic_stream_read_nonblock_m(VALUE self, VALUE length_v) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
@@ -241,7 +246,8 @@ quic_stream_read_nonblock_m(VALUE self, VALUE length_v)
 
   /* Drop the first |take| bytes from buffer by memmove + truncate. */
   if (take < have) {
-    memmove(RSTRING_PTR(buffer), RSTRING_PTR(buffer) + take, (size_t)(have - take));
+    memmove(RSTRING_PTR(buffer), RSTRING_PTR(buffer) + take,
+            (size_t)(have - take));
   }
   rb_str_set_len(buffer, have - take);
 
@@ -253,17 +259,17 @@ quic_stream_read_nonblock_m(VALUE self, VALUE length_v)
   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);
+    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;
 }
 
-static VALUE
-quic_stream_eof_p(VALUE self)
-{
+static VALUE quic_stream_eof_p(VALUE self) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
   VALUE buffer = rb_ivar_get(self, rb_intern("@recv_buffer"));
@@ -275,17 +281,13 @@ quic_stream_eof_p(VALUE self)
    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)
-{
+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)
-{
+static VALUE quic_stream_close_read_m(VALUE self) {
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
@@ -295,13 +297,12 @@ quic_stream_close_read_m(VALUE self)
   /* ngtcp2_conn_shutdown_stream_read sends STOP_SENDING. app_error_code 0
      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);
+  if (rv != 0)
+    quic_raise_ngtcp2_error(rv);
   return Qnil;
 }
 
-static VALUE
-quic_stream_close_m(VALUE self)
-{
+static VALUE quic_stream_close_m(VALUE self) {
   /* Send FIN (if not yet) then STOP_SENDING. Idempotent on each leg. */
   quic_stream_close_write_m(self);
   quic_stream_close_read_m(self);
@@ -318,9 +319,7 @@ quic_stream_close_m(VALUE self)
    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)
-{
+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);
@@ -328,17 +327,19 @@ quic_stream_reset_m(int argc, VALUE *argv, VALUE self)
   quic_stream_t *s;
   TypedData_Get_Struct(self, quic_stream_t, &quic_stream_data_type, s);
 
-  if (s->reset) return Qnil;  /* idempotent */
+  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 */
+    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);
+  if (rv != 0)
+    quic_raise_ngtcp2_error(rv);
   s->reset = true;
   return Qnil;
 }
@@ -346,9 +347,7 @@ quic_stream_reset_m(int argc, VALUE *argv, VALUE self)
 /* 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)
-{
+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;
@@ -362,20 +361,21 @@ quic_stream_accepted_m(VALUE self)
   return Qnil;
 }
 
-void
-Init_quic_stream(VALUE rb_mQUICArg)
-{
+void 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, "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, "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);
+  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

@@ -22,13 +22,19 @@ typedef struct {
   /* Cumulative bytes shifted out of @pending_chunks. Always
      <= acked_offset (we only shift a Chunk after its end is acked). */
   uint64_t pending_shifted;
-  bool fin_received;          /* recv_stream_data delivered FIN */
-  bool fin_sent;              /* #write(fin: true) queued FIN */
-  bool fin_flushed;           /* write_pkt actually wrote the FIN frame */
-  bool reset;                 /* stream_reset callback fired */
-  bool closed;                /* stream_close callback fired */
+  bool fin_received; /* recv_stream_data delivered FIN */
+  bool fin_sent;     /* #write(fin: true) queued FIN */
+  bool fin_flushed;  /* write_pkt actually wrote the FIN frame */
+  bool reset;        /* stream_reset callback fired */
+  bool closed;       /* stream_close callback fired */
   uint64_t close_app_error_code;
   bool close_has_app_error_code;
+  /* The send side is shut: the peer's STOP_SENDING arrived, or ngtcp2
+     reported the send side shut while writing. @pending_chunks has been
+     emptied, so the offsets above no longer describe it, and #write_pkt
+     skips the stream. */
+  bool stopped;
+  uint64_t stop_app_error_code; /* the STOP_SENDING's, 0 if none arrived */
   /* 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. */

data/ext/quic/tls_context.c

@@ -11,20 +11,17 @@
 
 VALUE rb_cQUICTLSContext;
 
-void
-quic_tls_ctx_ref(quic_tls_ctx_t *t)
-{
-  t->refcnt++;
-}
+void quic_tls_ctx_ref(quic_tls_ctx_t *t) { t->refcnt++; }
 
-void
-quic_tls_ctx_unref(quic_tls_ctx_t *t)
-{
-  if (--t->refcnt > 0) return;
-  if (t->sign_cert_initialized) ptls_openssl_dispose_sign_certificate(&t->sign_cert);
+void quic_tls_ctx_unref(quic_tls_ctx_t *t) {
+  if (--t->refcnt > 0)
+    return;
+  if (t->sign_cert_initialized)
+    ptls_openssl_dispose_sign_certificate(&t->sign_cert);
   /* picotls malloc()ed the list and each entry, so free(), not xfree(). */
   if (t->ctx.certificates.list != NULL) {
-    for (size_t i = 0; i < t->ctx.certificates.count; i++) free(t->ctx.certificates.list[i].base);
+    for (size_t i = 0; i < t->ctx.certificates.count; i++)
+      free(t->ctx.certificates.list[i].base);
     free(t->ctx.certificates.list);
   }
   xfree(t->alpn);
@@ -34,30 +31,31 @@ quic_tls_ctx_unref(quic_tls_ctx_t *t)
 
 /* The QUIC::TLSContext object holds one reference. A context it never
    finished building (an exception mid-way) is released the same way. */
-static void
-quic_tls_context_free(void *ptr)
-{
-  if (ptr != NULL) quic_tls_ctx_unref((quic_tls_ctx_t *)ptr);
+static void quic_tls_context_free(void *ptr) {
+  if (ptr != NULL)
+    quic_tls_ctx_unref((quic_tls_ctx_t *)ptr);
 }
 
-static size_t
-quic_tls_context_size(const void *ptr)
-{
+static size_t quic_tls_context_size(const void *ptr) {
   (void)ptr;
   return sizeof(quic_tls_ctx_t);
 }
 
 static const rb_data_type_t quic_tls_context_type = {
-  "QUIC::TLSContext",
-  {NULL, quic_tls_context_free, quic_tls_context_size,},
-  NULL, NULL,
-  RUBY_TYPED_FREE_IMMEDIATELY,
+    "QUIC::TLSContext",
+    {
+        NULL,
+        quic_tls_context_free,
+        quic_tls_context_size,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-quic_tls_ctx_t *
-quic_tls_context_get(VALUE tls_context)
-{
-  return (quic_tls_ctx_t *)rb_check_typeddata(tls_context, &quic_tls_context_type);
+quic_tls_ctx_t *quic_tls_context_get(VALUE tls_context) {
+  return (quic_tls_ctx_t *)rb_check_typeddata(tls_context,
+                                              &quic_tls_context_type);
 }
 
 /* Pick the first of the server's ALPN protocols, in the server's order of
@@ -65,16 +63,19 @@ quic_tls_context_get(VALUE tls_context)
    held and never touches Ruby objects. */
 static int
 quic_tls_on_client_hello_cb(ptls_on_client_hello_t *self, ptls_t *tls,
-                            ptls_on_client_hello_parameters_t *params)
-{
-  quic_tls_ctx_t *t = (quic_tls_ctx_t *)((char *)self - offsetof(quic_tls_ctx_t, on_client_hello));
+                            ptls_on_client_hello_parameters_t *params) {
+  quic_tls_ctx_t *t =
+      (quic_tls_ctx_t *)((char *)self -
+                         offsetof(quic_tls_ctx_t, on_client_hello));
   for (size_t i = 0; i < t->alpn_count; i++) {
     for (size_t j = 0; j < params->negotiated_protocols.count; j++) {
       ptls_iovec_t offered = params->negotiated_protocols.list[j];
       if (offered.len == t->alpn[i].len &&
           memcmp(offered.base, t->alpn[i].base, offered.len) == 0) {
-        return ptls_set_negotiated_protocol(tls, (const char *)offered.base, offered.len) == 0
-          ? 0 : PTLS_ERROR_NO_MEMORY;
+        return ptls_set_negotiated_protocol(tls, (const char *)offered.base,
+                                            offered.len) == 0
+                   ? 0
+                   : PTLS_ERROR_NO_MEMORY;
       }
     }
   }
@@ -84,9 +85,8 @@ quic_tls_on_client_hello_cb(ptls_on_client_hello_t *self, ptls_t *tls,
 /* Never supply a passphrase. Without a callback, PEM_read_bio_PrivateKey
    falls back to PEM_def_callback, which prompts on the controlling terminal;
    this way an encrypted key fails to load like any other unreadable one. */
-static int
-quic_tls_no_passphrase_cb(char *buf, int size, int rwflag, void *userdata)
-{
+static int quic_tls_no_passphrase_cb(char *buf, int size, int rwflag,
+                                     void *userdata) {
   (void)buf;
   (void)size;
   (void)rwflag;
@@ -100,10 +100,9 @@ quic_tls_no_passphrase_cb(char *buf, int size, int rwflag, void *userdata)
    raises ArgumentError naming the step that failed. Everything allocated
    here is released before raising, and libcrypto's error queue, which is
    shared with Ruby's openssl extension, is left empty on every return. */
-static void
-quic_tls_ctx_load_certificate_and_key(quic_tls_ctx_t *t, VALUE certificate_path,
-                                      VALUE private_key_path)
-{
+static void quic_tls_ctx_load_certificate_and_key(quic_tls_ctx_t *t,
+                                                  VALUE certificate_path,
+                                                  VALUE private_key_path) {
   VALUE failure_class = rb_eArgError;
   const char *failure = NULL;
   VALUE failed_path = Qnil;
@@ -118,7 +117,8 @@ quic_tls_ctx_load_certificate_and_key(quic_tls_ctx_t *t, VALUE certificate_path,
   ERR_clear_error();
 
   cert_bio = BIO_new_file(RSTRING_PTR(certificate_path), "r");
-  if (cert_bio == NULL || (leaf = PEM_read_bio_X509(cert_bio, NULL, NULL, NULL)) == NULL) {
+  if (cert_bio == NULL ||
+      (leaf = PEM_read_bio_X509(cert_bio, NULL, NULL, NULL)) == NULL) {
     failure = "failed to load certificate";
     failed_path = certificate_path;
     goto done;
@@ -138,9 +138,11 @@ quic_tls_ctx_load_certificate_and_key(quic_tls_ctx_t *t, VALUE certificate_path,
     }
   }
   /* The loop ends with PEM_R_NO_START_LINE once no PEM block is left. Any
-     other error means a broken block, as in SSL_CTX_use_certificate_chain_file. */
+     other error means a broken block, as in SSL_CTX_use_certificate_chain_file.
+   */
   err = ERR_peek_last_error();
-  if (ERR_GET_LIB(err) != ERR_LIB_PEM || ERR_GET_REASON(err) != PEM_R_NO_START_LINE) {
+  if (ERR_GET_LIB(err) != ERR_LIB_PEM ||
+      ERR_GET_REASON(err) != PEM_R_NO_START_LINE) {
     failure = "failed to load certificate";
     failed_path = certificate_path;
     goto done;
@@ -148,7 +150,8 @@ quic_tls_ctx_load_certificate_and_key(quic_tls_ctx_t *t, VALUE certificate_path,
 
   key_bio = BIO_new_file(RSTRING_PTR(private_key_path), "r");
   if (key_bio == NULL ||
-      (pkey = PEM_read_bio_PrivateKey(key_bio, NULL, quic_tls_no_passphrase_cb, NULL)) == NULL) {
+      (pkey = PEM_read_bio_PrivateKey(key_bio, NULL, quic_tls_no_passphrase_cb,
+                                      NULL)) == NULL) {
     failure = "failed to load private key";
     failed_path = private_key_path;
     goto done;
@@ -186,22 +189,27 @@ done:
   BIO_free(key_bio);
   ERR_clear_error();
 
-  if (failure == NULL) return;
-  if (NIL_P(failed_path)) rb_raise(failure_class, "%s", failure);
-  rb_raise(failure_class, "%s: %"PRIsVALUE, failure, failed_path);
+  if (failure == NULL)
+    return;
+  if (NIL_P(failed_path))
+    rb_raise(failure_class, "%s", failure);
+  rb_raise(failure_class, "%s: %" PRIsVALUE, failure, failed_path);
 }
 
 VALUE
-quic_tls_context_server_new(VALUE certificate_path, VALUE private_key_path, VALUE alpn_ary)
-{
+quic_tls_context_server_new(VALUE certificate_path, VALUE private_key_path,
+                            VALUE alpn_ary) {
   certificate_path = quic_path_value(certificate_path, "certificate_path");
   private_key_path = quic_path_value(private_key_path, "private_key_path");
-  if (NIL_P(certificate_path)) rb_raise(rb_eArgError, "certificate_path must not be nil");
-  if (NIL_P(private_key_path)) rb_raise(rb_eArgError, "private_key_path must not be nil");
+  if (NIL_P(certificate_path))
+    rb_raise(rb_eArgError, "certificate_path must not be nil");
+  if (NIL_P(private_key_path))
+    rb_raise(rb_eArgError, "private_key_path must not be nil");
 
   /* The object owns the context from the start, so that an exception below
      releases whatever was built so far. */
-  VALUE self = TypedData_Wrap_Struct(rb_cQUICTLSContext, &quic_tls_context_type, NULL);
+  VALUE self =
+      TypedData_Wrap_Struct(rb_cQUICTLSContext, &quic_tls_context_type, NULL);
   quic_tls_ctx_t *t = ZALLOC(quic_tls_ctx_t);
   t->refcnt = 1;
   DATA_PTR(self) = t;
@@ -209,21 +217,23 @@ quic_tls_context_server_new(VALUE certificate_path, VALUE private_key_path, VALU
   /* Without an ALPN to pick, every handshake would end in
      no_application_protocol. */
   quic_copy_alpn(alpn_ary, &t->alpn, &t->alpn_count, &t->alpn_buf);
-  if (t->alpn_count == 0) rb_raise(rb_eArgError, "alpn must not be empty for a server");
+  if (t->alpn_count == 0)
+    rb_raise(rb_eArgError, "alpn must not be empty for a server");
 
   t->ctx = (ptls_context_t){
-    .random_bytes = ptls_openssl_random_bytes,
-    .get_time = &ptls_get_time,
-    .key_exchanges = quic_key_exchanges,
-    .cipher_suites = quic_cipher_suites,
-    /* No session resumption: encrypt_ticket stays NULL, so no ticket is
-       ever issued. Keep this so that PSK-only resumption is refused once
-       resumption is added. */
-    .require_dhe_on_psk = 1,
-    .server_cipher_preference = 1,
+      .random_bytes = ptls_openssl_random_bytes,
+      .get_time = &ptls_get_time,
+      .key_exchanges = quic_key_exchanges,
+      .cipher_suites = quic_cipher_suites,
+      /* No session resumption: encrypt_ticket stays NULL, so no ticket is
+         ever issued. Keep this so that PSK-only resumption is refused once
+         resumption is added. */
+      .require_dhe_on_psk = 1,
+      .server_cipher_preference = 1,
   };
   if (ngtcp2_crypto_picotls_configure_server_context(&t->ctx) != 0) {
-    rb_raise(rb_eRuntimeError, "ngtcp2_crypto_picotls_configure_server_context failed");
+    rb_raise(rb_eRuntimeError,
+             "ngtcp2_crypto_picotls_configure_server_context failed");
   }
   /* verify_certificate stays NULL: no client certificate is requested. */
   quic_tls_ctx_load_certificate_and_key(t, certificate_path, private_key_path);
@@ -234,13 +244,12 @@ quic_tls_context_server_new(VALUE certificate_path, VALUE private_key_path, VALU
 
 /* QUIC::TLSContext.server(certificate_path:, private_key_path:, alpn:). A
    missing or unknown keyword raises ArgumentError as a Ruby method would. */
-static VALUE
-quic_tls_context_s_server(int argc, VALUE *argv, VALUE klass)
-{
+static VALUE quic_tls_context_s_server(int argc, VALUE *argv, VALUE klass) {
   (void)klass;
   VALUE opts = Qnil;
   rb_scan_args(argc, argv, "0:", &opts);
-  if (NIL_P(opts)) opts = rb_hash_new();
+  if (NIL_P(opts))
+    opts = rb_hash_new();
 
   ID keywords[3];
   VALUE values[3];
@@ -251,10 +260,10 @@ quic_tls_context_s_server(int argc, VALUE *argv, VALUE klass)
   return quic_tls_context_server_new(values[0], values[1], values[2]);
 }
 
-void
-Init_quic_tls_context(VALUE rb_mQUICArg)
-{
-  rb_cQUICTLSContext = rb_define_class_under(rb_mQUICArg, "TLSContext", rb_cObject);
+void Init_quic_tls_context(VALUE rb_mQUICArg) {
+  rb_cQUICTLSContext =
+      rb_define_class_under(rb_mQUICArg, "TLSContext", rb_cObject);
   rb_undef_alloc_func(rb_cQUICTLSContext);
-  rb_define_singleton_method(rb_cQUICTLSContext, "server", quic_tls_context_s_server, -1);
+  rb_define_singleton_method(rb_cQUICTLSContext, "server",
+                             quic_tls_context_s_server, -1);
 }

data/ext/quic/tls_context.h

@@ -34,7 +34,8 @@ void Init_quic_tls_context(VALUE rb_mQUICArg);
    holding the one reference to a new context. alpn_ary must be a non-empty
    Array of 1-255 byte Strings. Raises ArgumentError naming what could not
    be loaded or used. */
-VALUE quic_tls_context_server_new(VALUE certificate_path, VALUE private_key_path, VALUE alpn_ary);
+VALUE quic_tls_context_server_new(VALUE certificate_path,
+                                  VALUE private_key_path, VALUE alpn_ary);
 
 /* The context behind a QUIC::TLSContext object. Raises TypeError for any
    other object. */

data/lib/quic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QUIC
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end