quic 0.0.3 → 0.0.5

data/ext/quic/endpoint.c

@@ -58,35 +58,29 @@ struct quic_endpoint {
    collide. */
 static st_index_t quic_cid_hash_seed;
 
-static int
-quic_cid_cmp(st_data_t a, st_data_t b)
-{
+static int quic_cid_cmp(st_data_t a, st_data_t b) {
   return !ngtcp2_cid_eq((const ngtcp2_cid *)a, (const ngtcp2_cid *)b);
 }
 
-static st_index_t
-quic_cid_hash(st_data_t a)
-{
+static st_index_t quic_cid_hash(st_data_t a) {
   const ngtcp2_cid *cid = (const ngtcp2_cid *)a;
   return st_hash(cid->data, cid->datalen, quic_cid_hash_seed);
 }
 
-static const struct st_hash_type quic_cid_hash_type = {quic_cid_cmp, quic_cid_hash};
+static const struct st_hash_type quic_cid_hash_type = {quic_cid_cmp,
+                                                       quic_cid_hash};
 
-static int
-quic_endpoint_mark_i(st_data_t key, st_data_t value, st_data_t arg)
-{
+static int quic_endpoint_mark_i(st_data_t key, st_data_t value, st_data_t arg) {
   (void)key;
   (void)arg;
   rb_gc_mark_movable((VALUE)value);
   return ST_CONTINUE;
 }
 
-static void
-quic_endpoint_mark(void *ptr)
-{
+static void quic_endpoint_mark(void *ptr) {
   quic_endpoint_t *ep = (quic_endpoint_t *)ptr;
-  if (ep->cids != NULL) st_foreach(ep->cids, quic_endpoint_mark_i, 0);
+  if (ep->cids != NULL)
+    st_foreach(ep->cids, quic_endpoint_mark_i, 0);
   rb_gc_mark_movable(ep->conns);
   rb_gc_mark_movable(ep->responses);
   rb_gc_mark_movable(ep->closed);
@@ -96,9 +90,8 @@ quic_endpoint_mark(void *ptr)
   rb_gc_mark_movable(ep->settings);
 }
 
-static int
-quic_endpoint_compact_check_i(st_data_t key, st_data_t value, st_data_t arg, int error)
-{
+static int quic_endpoint_compact_check_i(st_data_t key, st_data_t value,
+                                         st_data_t arg, int error) {
   (void)key;
   (void)value;
   (void)arg;
@@ -106,9 +99,8 @@ quic_endpoint_compact_check_i(st_data_t key, st_data_t value, st_data_t arg, int
   return ST_REPLACE;
 }
 
-static int
-quic_endpoint_compact_replace_i(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
-{
+static int quic_endpoint_compact_replace_i(st_data_t *key, st_data_t *value,
+                                           st_data_t arg, int existing) {
   (void)key;
   (void)arg;
   (void)existing;
@@ -116,9 +108,7 @@ quic_endpoint_compact_replace_i(st_data_t *key, st_data_t *value, st_data_t arg,
   return ST_CONTINUE;
 }
 
-static void
-quic_endpoint_compact(void *ptr)
-{
+static void quic_endpoint_compact(void *ptr) {
   quic_endpoint_t *ep = (quic_endpoint_t *)ptr;
   if (ep->cids != NULL) {
     st_foreach_with_replace(ep->cids, quic_endpoint_compact_check_i,
@@ -133,9 +123,8 @@ quic_endpoint_compact(void *ptr)
   ep->settings = rb_gc_location(ep->settings);
 }
 
-static int
-quic_endpoint_free_key_i(st_data_t key, st_data_t value, st_data_t arg)
-{
+static int quic_endpoint_free_key_i(st_data_t key, st_data_t value,
+                                    st_data_t arg) {
   (void)value;
   (void)arg;
   xfree((void *)key);
@@ -144,9 +133,7 @@ quic_endpoint_free_key_i(st_data_t key, st_data_t value, st_data_t arg)
 
 /* Connections still in the table are unreachable too (each marks the
    Endpoint), and quic_conn_free never reaches back here. */
-static void
-quic_endpoint_free(void *ptr)
-{
+static void quic_endpoint_free(void *ptr) {
   quic_endpoint_t *ep = (quic_endpoint_t *)ptr;
   if (ep->cids != NULL) {
     st_foreach(ep->cids, quic_endpoint_free_key_i, 0);
@@ -156,31 +143,32 @@ quic_endpoint_free(void *ptr)
   xfree(ep);
 }
 
-static size_t
-quic_endpoint_size(const void *ptr)
-{
+static size_t quic_endpoint_size(const void *ptr) {
   const quic_endpoint_t *ep = (const quic_endpoint_t *)ptr;
   return sizeof(*ep) + (ep->cids != NULL ? st_memsize(ep->cids) : 0);
 }
 
 static const rb_data_type_t quic_endpoint_data_type = {
-  "QUIC::Endpoint",
-  {quic_endpoint_mark, quic_endpoint_free, quic_endpoint_size, quic_endpoint_compact,},
-  NULL, NULL,
-  RUBY_TYPED_FREE_IMMEDIATELY,
+    "QUIC::Endpoint",
+    {
+        quic_endpoint_mark,
+        quic_endpoint_free,
+        quic_endpoint_size,
+        quic_endpoint_compact,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static quic_endpoint_t *
-quic_endpoint_get(VALUE self)
-{
+static quic_endpoint_t *quic_endpoint_get(VALUE self) {
   quic_endpoint_t *ep;
   TypedData_Get_Struct(self, quic_endpoint_t, &quic_endpoint_data_type, ep);
   return ep;
 }
 
-void
-quic_endpoint_associate_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) {
   /* For a key already there, st_insert replaces the value and keeps the
      key it has, so a copy is made only for a new key. */
   if (st_lookup(ep->cids, (st_data_t)cid, NULL)) {
@@ -192,68 +180,65 @@ quic_endpoint_associate_cid(quic_endpoint_t *ep, const ngtcp2_cid *cid, VALUE co
   st_insert(ep->cids, (st_data_t)key, (st_data_t)conn);
 }
 
-void
-quic_endpoint_dissociate_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) {
   st_data_t key = (st_data_t)cid;
   st_data_t value;
-  if (!st_lookup(ep->cids, key, &value) || (VALUE)value != conn) return;
+  if (!st_lookup(ep->cids, key, &value) || (VALUE)value != conn)
+    return;
   /* st_delete hands back the stored key. */
-  if (st_delete(ep->cids, &key, &value)) xfree((void *)key);
+  if (st_delete(ep->cids, &key, &value))
+    xfree((void *)key);
 }
 
-int
-quic_endpoint_generate_reset_token(const quic_endpoint_t *ep, uint8_t *token,
-                                   const ngtcp2_cid *cid)
-{
-  return ngtcp2_crypto_generate_stateless_reset_token(token, ep->reset_secret,
-                                                      sizeof(ep->reset_secret), cid) == 0
-    ? 0 : -1;
+int quic_endpoint_generate_reset_token(const quic_endpoint_t *ep,
+                                       uint8_t *token, const ngtcp2_cid *cid) {
+  return ngtcp2_crypto_generate_stateless_reset_token(
+             token, ep->reset_secret, sizeof(ep->reset_secret), cid) == 0
+             ? 0
+             : -1;
 }
 
-static VALUE
-quic_addr_str(const ngtcp2_addr *addr)
-{
+static VALUE quic_addr_str(const ngtcp2_addr *addr) {
   return rb_str_new((const char *)addr->addr, (long)addr->addrlen);
 }
 
 /* Queue an answer for #write_pkt. Returns false when the queue is full and
    the answer was dropped. */
-static bool
-quic_endpoint_push_response(quic_endpoint_t *ep, VALUE pkt, VALUE to)
-{
-  if (RARRAY_LEN(ep->responses) >= QUIC_ENDPOINT_MAX_RESPONSES) return false;
+static bool quic_endpoint_push_response(quic_endpoint_t *ep, VALUE pkt,
+                                        VALUE to) {
+  if (RARRAY_LEN(ep->responses) >= QUIC_ENDPOINT_MAX_RESPONSES)
+    return false;
   rb_ary_push(ep->responses, rb_assoc_new(pkt, to));
   return true;
 }
 
-static void
-quic_conn_set_error(quic_conn_t *c, VALUE exc)
-{
+static void quic_conn_set_error(quic_conn_t *c, VALUE exc) {
   /* The first failure is the reason; what follows is its consequence. */
-  if (NIL_P(c->error)) c->error = exc;
+  if (NIL_P(c->error))
+    c->error = exc;
 }
 
 /* Take the Stateless Resets that came back since the last call, one per
    whole second. Computed on read_pkt rather than with a timer. */
-static void
-quic_endpoint_refill_reset_bucket(quic_endpoint_t *ep, ngtcp2_tstamp now)
-{
+static void quic_endpoint_refill_reset_bucket(quic_endpoint_t *ep,
+                                              ngtcp2_tstamp now) {
   if (ep->reset_bucket >= QUIC_STATELESS_RESET_BURST) {
     ep->reset_refill_ts = now;
     return;
   }
   uint64_t n = (now - ep->reset_refill_ts) / NGTCP2_SECONDS;
-  if (n == 0) return;
+  if (n == 0)
+    return;
   ep->reset_bucket = n >= QUIC_STATELESS_RESET_BURST - ep->reset_bucket
-    ? QUIC_STATELESS_RESET_BURST : ep->reset_bucket + (size_t)n;
+                         ? QUIC_STATELESS_RESET_BURST
+                         : ep->reset_bucket + (size_t)n;
   ep->reset_refill_ts += n * NGTCP2_SECONDS;
 }
 
-static void
-quic_endpoint_send_version_negotiation(quic_endpoint_t *ep, const ngtcp2_version_cid *vc,
-                                       VALUE remote)
-{
+static void quic_endpoint_send_version_negotiation(quic_endpoint_t *ep,
+                                                   const ngtcp2_version_cid *vc,
+                                                   VALUE remote) {
   uint8_t unused_bits;
   uint32_t grease;
   if (RAND_bytes(&unused_bits, 1) != 1 ||
@@ -263,77 +248,87 @@ quic_endpoint_send_version_negotiation(quic_endpoint_t *ep, const ngtcp2_version
   /* A reserved version (0x?a?a?a?a) ahead of the one supported, so that
      clients keep handling versions they do not know (RFC 9000 section
      6.3). */
-  uint32_t versions[] = {(grease & 0xf0f0f0f0U) | 0x0a0a0a0aU, NGTCP2_PROTO_VER_V1};
+  uint32_t versions[] = {(grease & 0xf0f0f0f0U) | 0x0a0a0a0aU,
+                         NGTCP2_PROTO_VER_V1};
 
   VALUE pkt = rb_str_buf_new(NGTCP2_MAX_UDP_PAYLOAD_SIZE);
   ngtcp2_ssize n = ngtcp2_pkt_write_version_negotiation(
-    (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, unused_bits, vc->scid, vc->scidlen,
-    vc->dcid, vc->dcidlen, versions, sizeof(versions) / sizeof(versions[0]));
-  if (n <= 0) return;
+      (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, unused_bits,
+      vc->scid, vc->scidlen, vc->dcid, vc->dcidlen, versions,
+      sizeof(versions) / sizeof(versions[0]));
+  if (n <= 0)
+    return;
   rb_str_set_len(pkt, n);
   quic_endpoint_push_response(ep, pkt, rb_str_dup(remote));
 }
 
 /* Tell the peer that this Endpoint has no state for dcid, as
    examples/server.cc's send_stateless_reset does. */
-static void
-quic_endpoint_send_stateless_reset(quic_endpoint_t *ep, const ngtcp2_cid *dcid, size_t pktlen,
-                                   VALUE remote)
-{
-  if (ep->reset_bucket == 0) return;
+static void quic_endpoint_send_stateless_reset(quic_endpoint_t *ep,
+                                               const ngtcp2_cid *dcid,
+                                               size_t pktlen, VALUE remote) {
+  if (ep->reset_bucket == 0)
+    return;
   ep->reset_bucket--;
 
   ngtcp2_stateless_reset_token token;
-  if (quic_endpoint_generate_reset_token(ep, token.data, dcid) != 0) return;
+  if (quic_endpoint_generate_reset_token(ep, token.data, dcid) != 0)
+    return;
 
   /* Shorter than the packet that prompted it, so that two endpoints cannot
      keep answering each other's resets (RFC 9000 section 10.3.3): one byte
      shorter up to 43 bytes, 42 bytes beyond. */
-  enum { MAX_RANDLEN = NGTCP2_MAX_CIDLEN + 22 - NGTCP2_STATELESS_RESET_TOKENLEN };
+  enum {
+    MAX_RANDLEN = NGTCP2_MAX_CIDLEN + 22 - NGTCP2_STATELESS_RESET_TOKENLEN
+  };
   uint8_t rand_bytes[MAX_RANDLEN];
-  size_t randlen = pktlen <= 43 ? pktlen - NGTCP2_STATELESS_RESET_TOKENLEN - 1 : MAX_RANDLEN;
-  if (RAND_bytes(rand_bytes, (int)randlen) != 1) return;
+  size_t randlen =
+      pktlen <= 43 ? pktlen - NGTCP2_STATELESS_RESET_TOKENLEN - 1 : MAX_RANDLEN;
+  if (RAND_bytes(rand_bytes, (int)randlen) != 1)
+    return;
 
   VALUE pkt = rb_str_buf_new(NGTCP2_MAX_UDP_PAYLOAD_SIZE);
   ngtcp2_ssize n = ngtcp2_pkt_write_stateless_reset2(
-    (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, &token, rand_bytes, randlen);
-  if (n <= 0) return;
+      (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, &token,
+      rand_bytes, randlen);
+  if (n <= 0)
+    return;
   rb_str_set_len(pkt, n);
   quic_endpoint_push_response(ep, pkt, rb_str_dup(remote));
 }
 
 /* Turn a new connection away with CONNECTION_REFUSED in an Initial packet,
    without making any state for it. */
-static void
-quic_endpoint_refuse(quic_endpoint_t *ep, const ngtcp2_pkt_hd *hd, VALUE remote)
-{
+static void quic_endpoint_refuse(quic_endpoint_t *ep, const ngtcp2_pkt_hd *hd,
+                                 VALUE remote) {
   VALUE pkt = rb_str_buf_new(NGTCP2_MAX_UDP_PAYLOAD_SIZE);
   /* Despite its documentation, this returns the packet's length. */
   ngtcp2_ssize n = ngtcp2_crypto_write_connection_close(
-    (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, hd->version, &hd->scid, &hd->dcid,
-    NGTCP2_CONNECTION_REFUSED, NULL, 0);
-  if (n <= 0) return;
+      (uint8_t *)RSTRING_PTR(pkt), NGTCP2_MAX_UDP_PAYLOAD_SIZE, hd->version,
+      &hd->scid, &hd->dcid, NGTCP2_CONNECTION_REFUSED, NULL, 0);
+  if (n <= 0)
+    return;
   rb_str_set_len(pkt, n);
   quic_endpoint_push_response(ep, pkt, rb_str_dup(remote));
 }
 
 /* The closing and draining periods last three PTOs (RFC 9000 section
    10.2). */
-static ngtcp2_tstamp
-quic_close_deadline(const quic_conn_t *c, ngtcp2_tstamp now)
-{
+static ngtcp2_tstamp quic_close_deadline(const quic_conn_t *c,
+                                         ngtcp2_tstamp now) {
   return now + 3 * ngtcp2_conn_get_pto2(c->conn);
 }
 
 /* Enter the closing period with a CONNECTION_CLOSE carrying ccerr, and
    queue that packet. Returns false when ngtcp2 cannot build it; the
    connection then has to leave the table at once. */
-static bool
-quic_endpoint_start_closing(quic_endpoint_t *ep, quic_conn_t *c, const ngtcp2_ccerr *ccerr)
-{
+static bool quic_endpoint_start_closing(quic_endpoint_t *ep, quic_conn_t *c,
+                                        const ngtcp2_ccerr *ccerr) {
   ngtcp2_tstamp now = quic_now();
-  if (ngtcp2_conn_in_closing_period2(c->conn) || ngtcp2_conn_in_draining_period2(c->conn)) {
-    if (c->close_deadline == 0) c->close_deadline = quic_close_deadline(c, now);
+  if (ngtcp2_conn_in_closing_period2(c->conn) ||
+      ngtcp2_conn_in_draining_period2(c->conn)) {
+    if (c->close_deadline == 0)
+      c->close_deadline = quic_close_deadline(c, now);
     return true;
   }
 
@@ -342,15 +337,19 @@ quic_endpoint_start_closing(quic_endpoint_t *ep, quic_conn_t *c, const ngtcp2_cc
   ngtcp2_pkt_info pi;
   VALUE pkt = rb_str_buf_new(QUIC_WRITE_PKT_BUFLEN);
   ngtcp2_ssize n = ngtcp2_conn_write_connection_close(
-    c->conn, &ps.path, &pi, (uint8_t *)RSTRING_PTR(pkt), QUIC_WRITE_PKT_BUFLEN, ccerr, now);
-  if (n < 0) return false;
+      c->conn, &ps.path, &pi, (uint8_t *)RSTRING_PTR(pkt),
+      QUIC_WRITE_PKT_BUFLEN, ccerr, now);
+  if (n < 0)
+    return false;
 
   c->close_deadline = quic_close_deadline(c, now);
   c->close_next_pkts_recv = 1;
-  if (n == 0) return true;
+  if (n == 0)
+    return true;
   rb_str_set_len(pkt, n);
   c->closebuf = pkt;
-  quic_endpoint_push_response(ep, rb_str_dup(pkt), quic_addr_str(&ps.path.remote));
+  quic_endpoint_push_response(ep, rb_str_dup(pkt),
+                              quic_addr_str(&ps.path.remote));
   return true;
 }
 
@@ -358,10 +357,10 @@ quic_endpoint_start_closing(quic_endpoint_t *ep, quic_conn_t *c, const ngtcp2_cc
    CONNECTION_CLOSE again, but no more than three times what the peer sent
    and to every 1st, 2nd, 4th, 8th, ... packet only (examples/server.cc's
    Handler::send_conn_close). */
-static void
-quic_endpoint_resend_close(quic_endpoint_t *ep, quic_conn_t *c, size_t pktlen, VALUE remote)
-{
-  if (NIL_P(c->closebuf)) return;
+static void quic_endpoint_resend_close(quic_endpoint_t *ep, quic_conn_t *c,
+                                       size_t pktlen, VALUE remote) {
+  if (NIL_P(c->closebuf))
+    return;
 
   c->close_bytes_recv += pktlen;
   c->close_pkts_recv++;
@@ -370,7 +369,9 @@ quic_endpoint_resend_close(quic_endpoint_t *ep, quic_conn_t *c, size_t pktlen, V
       c->close_bytes_recv * 3 < c->close_bytes_sent + len) {
     return;
   }
-  if (!quic_endpoint_push_response(ep, rb_str_dup(c->closebuf), rb_str_dup(remote))) return;
+  if (!quic_endpoint_push_response(ep, rb_str_dup(c->closebuf),
+                                   rb_str_dup(remote)))
+    return;
   c->close_bytes_sent += len;
   c->close_next_pkts_recv *= 2;
 }
@@ -380,12 +381,12 @@ quic_endpoint_resend_close(quic_endpoint_t *ep, quic_conn_t *c, size_t pktlen, V
    for it; the reason goes to c->error. Returns true when the connection has
    to leave the table now, false when it stays for its closing or draining
    period. */
-static bool
-quic_endpoint_handle_error(quic_endpoint_t *ep, quic_conn_t *c, int rv)
-{
+static bool quic_endpoint_handle_error(quic_endpoint_t *ep, quic_conn_t *c,
+                                       int rv) {
   VALUE exc = c->pending_exc;
   c->pending_exc = Qnil;
-  if (!NIL_P(exc)) rv = NGTCP2_ERR_CALLBACK_FAILURE;
+  if (!NIL_P(exc))
+    rv = NGTCP2_ERR_CALLBACK_FAILURE;
 
   ngtcp2_ccerr ccerr;
   switch (rv) {
@@ -412,7 +413,8 @@ quic_endpoint_handle_error(quic_endpoint_t *ep, quic_conn_t *c, int rv)
     /* Send the TLS alert itself, as examples/server.cc does; set_liberr
        would only know that the handshake failed. */
     quic_conn_set_error(c, quic_conn_error_new(c, rv));
-    ngtcp2_ccerr_set_tls_alert(&ccerr, ngtcp2_conn_get_tls_alert2(c->conn), NULL, 0);
+    ngtcp2_ccerr_set_tls_alert(&ccerr, ngtcp2_conn_get_tls_alert2(c->conn),
+                               NULL, 0);
     break;
   default:
     quic_conn_set_error(c, quic_conn_error_new(c, rv));
@@ -423,52 +425,55 @@ quic_endpoint_handle_error(quic_endpoint_t *ep, quic_conn_t *c, int rv)
 }
 
 /* Drop every table entry of conn and cut it loose from the Endpoint. */
-static void
-quic_endpoint_detach(quic_endpoint_t *ep, VALUE conn, quic_conn_t *c)
-{
-  quic_endpoint_dissociate_cid(ep, ngtcp2_conn_get_client_initial_dcid2(c->conn), conn);
+static void quic_endpoint_detach(quic_endpoint_t *ep, VALUE conn,
+                                 quic_conn_t *c) {
+  quic_endpoint_dissociate_cid(
+      ep, ngtcp2_conn_get_client_initial_dcid2(c->conn), conn);
 
   size_t n = ngtcp2_conn_get_scid2(c->conn, NULL);
   VALUE tmp;
   ngtcp2_cid *scids = ALLOCV_N(ngtcp2_cid, tmp, n);
   ngtcp2_conn_get_scid2(c->conn, scids);
-  for (size_t i = 0; i < n; i++) quic_endpoint_dissociate_cid(ep, &scids[i], conn);
+  for (size_t i = 0; i < n; i++)
+    quic_endpoint_dissociate_cid(ep, &scids[i], conn);
   ALLOCV_END(tmp);
 
   c->endpoint = NULL;
   c->endpoint_owner = Qnil;
+  /* The Endpoint never drives the connection again. */
+  quic_conn_close_qlog(c);
 }
 
 /* Take conn out of the table and hand it to #take_closed. */
-static void
-quic_endpoint_remove(quic_endpoint_t *ep, VALUE conn, quic_conn_t *c)
-{
+static void quic_endpoint_remove(quic_endpoint_t *ep, VALUE conn,
+                                 quic_conn_t *c) {
   quic_endpoint_detach(ep, conn, c);
   long len = RARRAY_LEN(ep->conns);
   for (long i = 0; i < len; i++) {
-    if (RARRAY_AREF(ep->conns, i) != conn) continue;
+    if (RARRAY_AREF(ep->conns, i) != conn)
+      continue;
     rb_ary_delete_at(ep->conns, i);
-    if (i < ep->write_cursor) ep->write_cursor--;
+    if (i < ep->write_cursor)
+      ep->write_cursor--;
     break;
   }
   rb_ary_push(ep->closed, conn);
 }
 
-void
-quic_endpoint_close_conn(quic_endpoint_t *ep, quic_conn_t *c, const ngtcp2_ccerr *ccerr)
-{
-  if (!quic_endpoint_start_closing(ep, c, ccerr)) quic_endpoint_remove(ep, c->owner, c);
+void quic_endpoint_close_conn(quic_endpoint_t *ep, quic_conn_t *c,
+                              const ngtcp2_ccerr *ccerr) {
+  if (!quic_endpoint_start_closing(ep, c, ccerr))
+    quic_endpoint_remove(ep, c->owner, c);
 }
 
 /* QUIC::Endpoint._new(local_sockaddr:, tls_context:, transport_params:,
    settings:, max_connections:), every keyword required. Endpoint.new
    (lib/quic/endpoint.rb) fills in the defaults. */
-static VALUE
-quic_endpoint_s_new(int argc, VALUE *argv, VALUE klass)
-{
+static VALUE quic_endpoint_s_new(int argc, VALUE *argv, VALUE 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[5];
   VALUE values[5];
@@ -489,11 +494,13 @@ quic_endpoint_s_new(int argc, VALUE *argv, VALUE klass)
   quic_fill_settings(&settings, values[3]);
   long max_connections = NUM2LONG(values[4]);
   if (max_connections <= 0) {
-    rb_raise(rb_eArgError, "max_connections must be positive (got %ld)", max_connections);
+    rb_raise(rb_eArgError, "max_connections must be positive (got %ld)",
+             max_connections);
   }
 
   quic_endpoint_t *ep;
-  VALUE self = TypedData_Make_Struct(klass, quic_endpoint_t, &quic_endpoint_data_type, ep);
+  VALUE self = TypedData_Make_Struct(klass, quic_endpoint_t,
+                                     &quic_endpoint_data_type, ep);
   ep->conns = Qnil;
   ep->responses = Qnil;
   ep->closed = Qnil;
@@ -524,9 +531,8 @@ struct quic_endpoint_read_args {
 };
 
 /* A packet for a connection in the table. */
-static VALUE
-quic_endpoint_dispatch(struct quic_endpoint_read_args *a, VALUE conn)
-{
+static VALUE quic_endpoint_dispatch(struct quic_endpoint_read_args *a,
+                                    VALUE conn) {
   quic_conn_t *c = quic_conn_get(conn);
   const uint8_t *data = (const uint8_t *)RSTRING_PTR(a->packet);
   size_t datalen = (size_t)RSTRING_LEN(a->packet);
@@ -535,10 +541,12 @@ quic_endpoint_dispatch(struct quic_endpoint_read_args *a, VALUE conn)
     quic_endpoint_resend_close(a->ep, c, datalen, a->remote);
     return Qnil;
   }
-  if (c->close_deadline != 0) return Qnil;
+  if (c->close_deadline != 0)
+    return Qnil;
 
   int rv = quic_conn_read_pkt_raw(c, &a->path, data, datalen);
-  if ((rv != 0 || !NIL_P(c->pending_exc)) && quic_endpoint_handle_error(a->ep, c, rv)) {
+  if ((rv != 0 || !NIL_P(c->pending_exc)) &&
+      quic_endpoint_handle_error(a->ep, c, rv)) {
     quic_endpoint_remove(a->ep, conn, c);
     return Qnil;
   }
@@ -547,9 +555,8 @@ quic_endpoint_dispatch(struct quic_endpoint_read_args *a, VALUE conn)
 
 /* A packet for no connection in the table: a new connection, or one this
    Endpoint has forgotten. */
-static VALUE
-quic_endpoint_accept(struct quic_endpoint_read_args *a, const ngtcp2_cid *dcid)
-{
+static VALUE quic_endpoint_accept(struct quic_endpoint_read_args *a,
+                                  const ngtcp2_cid *dcid) {
   quic_endpoint_t *ep = a->ep;
   const uint8_t *data = (const uint8_t *)RSTRING_PTR(a->packet);
   size_t datalen = (size_t)RSTRING_LEN(a->packet);
@@ -570,8 +577,9 @@ quic_endpoint_accept(struct quic_endpoint_read_args *a, const ngtcp2_cid *dcid)
   }
 
   /* As in Server._accept, a token is accepted without checking it. */
-  VALUE conn = quic_server_conn_new(rb_cQUICConnectionServer, &hd, &a->path, ep->tls_context,
-                                    ep->transport_params, ep->settings, ep, a->self);
+  VALUE conn = quic_server_conn_new(rb_cQUICConnectionServer, &hd, &a->path,
+                                    ep->tls_context, ep->transport_params,
+                                    ep->settings, ep, a->self);
   quic_conn_t *c = quic_conn_get(conn);
   int rv = quic_conn_read_pkt_raw(c, &a->path, data, datalen);
   if (rv != 0 || !NIL_P(c->pending_exc)) {
@@ -582,20 +590,20 @@ quic_endpoint_accept(struct quic_endpoint_read_args *a, const ngtcp2_cid *dcid)
     return Qnil;
   }
 
-  quic_endpoint_associate_cid(ep, ngtcp2_conn_get_client_initial_dcid2(c->conn), conn);
+  quic_endpoint_associate_cid(ep, ngtcp2_conn_get_client_initial_dcid2(c->conn),
+                              conn);
   size_t n = ngtcp2_conn_get_scid2(c->conn, NULL);
   VALUE tmp;
   ngtcp2_cid *scids = ALLOCV_N(ngtcp2_cid, tmp, n);
   ngtcp2_conn_get_scid2(c->conn, scids);
-  for (size_t i = 0; i < n; i++) quic_endpoint_associate_cid(ep, &scids[i], conn);
+  for (size_t i = 0; i < n; i++)
+    quic_endpoint_associate_cid(ep, &scids[i], conn);
   ALLOCV_END(tmp);
   rb_ary_push(ep->conns, conn);
   return conn;
 }
 
-static VALUE
-quic_endpoint_read_pkt_body(VALUE arg)
-{
+static VALUE quic_endpoint_read_pkt_body(VALUE arg) {
   struct quic_endpoint_read_args *a = (struct quic_endpoint_read_args *)arg;
   const uint8_t *data = (const uint8_t *)RSTRING_PTR(a->packet);
   size_t datalen = (size_t)RSTRING_LEN(a->packet);
@@ -603,7 +611,8 @@ quic_endpoint_read_pkt_body(VALUE arg)
   quic_endpoint_refill_reset_bucket(a->ep, quic_now());
 
   /* ngtcp2_pkt_decode_version_cid asserts datalen > 0. */
-  if (datalen == 0) return Qnil;
+  if (datalen == 0)
+    return Qnil;
 
   ngtcp2_version_cid vc;
   int rv = ngtcp2_pkt_decode_version_cid(&vc, data, datalen, QUIC_SCID_LEN);
@@ -612,7 +621,8 @@ quic_endpoint_read_pkt_body(VALUE arg)
     return Qnil;
   }
   /* A supported version never carries a DCID longer than this. */
-  if (rv != 0 || vc.dcidlen > NGTCP2_MAX_CIDLEN) return Qnil;
+  if (rv != 0 || vc.dcidlen > NGTCP2_MAX_CIDLEN)
+    return Qnil;
 
   ngtcp2_cid dcid;
   ngtcp2_cid_init(&dcid, vc.dcid, vc.dcidlen);
@@ -623,9 +633,7 @@ quic_endpoint_read_pkt_body(VALUE arg)
   return quic_endpoint_accept(a, &dcid);
 }
 
-static VALUE
-quic_endpoint_read_pkt_unlock(VALUE arg)
-{
+static VALUE quic_endpoint_read_pkt_unlock(VALUE arg) {
   rb_str_unlocktmp(((struct quic_endpoint_read_args *)arg)->packet);
   return Qnil;
 }
@@ -634,13 +642,12 @@ quic_endpoint_read_pkt_unlock(VALUE arg)
    Connection::Server it went to, which may be a new one, or nil when the
    Endpoint answered or dropped it. A connection's own failure is never
    raised; it closes that connection (see quic_endpoint_handle_error). */
-static VALUE
-quic_endpoint_read_pkt(int argc, VALUE *argv, VALUE self)
-{
+static VALUE quic_endpoint_read_pkt(int argc, VALUE *argv, VALUE self) {
   VALUE packet = Qnil;
   VALUE opts = Qnil;
   rb_scan_args(argc, argv, "1:", &packet, &opts);
-  if (NIL_P(opts)) opts = rb_hash_new();
+  if (NIL_P(opts))
+    opts = rb_hash_new();
 
   ID keywords[2];
   VALUE values[2];
@@ -650,7 +657,8 @@ quic_endpoint_read_pkt(int argc, VALUE *argv, VALUE self)
 
   quic_endpoint_t *ep = quic_endpoint_get(self);
   VALUE remote = values[0];
-  VALUE local = values[1] == Qundef || NIL_P(values[1]) ? ep->local_sockaddr : values[1];
+  VALUE local =
+      values[1] == Qundef || NIL_P(values[1]) ? ep->local_sockaddr : values[1];
   quic_require_binary(packet, "packet");
   quic_require_sockaddr(remote, "remote");
   quic_require_sockaddr(local, "local");
@@ -679,12 +687,11 @@ quic_endpoint_read_pkt(int argc, VALUE *argv, VALUE self)
    nil when there is none left. The Endpoint's own answers go first, then
    each connection's packets until it has none, resuming where the last
    call stopped. After nil, the next call starts over. */
-static VALUE
-quic_endpoint_write_pkt(VALUE self)
-{
+static VALUE quic_endpoint_write_pkt(VALUE self) {
   quic_endpoint_t *ep = quic_endpoint_get(self);
   for (;;) {
-    if (RARRAY_LEN(ep->responses) > 0) return rb_ary_shift(ep->responses);
+    if (RARRAY_LEN(ep->responses) > 0)
+      return rb_ary_shift(ep->responses);
     if (ep->write_cursor >= RARRAY_LEN(ep->conns)) {
       ep->write_cursor = 0;
       return Qnil;
@@ -701,7 +708,8 @@ quic_endpoint_write_pkt(VALUE self)
     VALUE pkt = rb_str_buf_new(QUIC_WRITE_PKT_BUFLEN);
     ngtcp2_path_storage ps;
     ngtcp2_path_storage_zero(&ps);
-    ngtcp2_ssize n = quic_conn_write_pkt_raw(conn, c, &ps.path, (uint8_t *)RSTRING_PTR(pkt));
+    ngtcp2_ssize n =
+        quic_conn_write_pkt_raw(conn, c, &ps.path, (uint8_t *)RSTRING_PTR(pkt));
     if (n < 0 || !NIL_P(c->pending_exc)) {
       if (quic_endpoint_handle_error(ep, c, n < 0 ? (int)n : 0)) {
         quic_endpoint_remove(ep, conn, c);
@@ -720,15 +728,15 @@ quic_endpoint_write_pkt(VALUE self)
 /* #expiry: the earliest time (CLOCK_MONOTONIC ns) any connection in the
    table needs #handle_expiry, the end of a closing or draining period
    included. nil when no connection waits for one. */
-static VALUE
-quic_endpoint_expiry(VALUE self)
-{
+static VALUE quic_endpoint_expiry(VALUE self) {
   quic_endpoint_t *ep = quic_endpoint_get(self);
   ngtcp2_tstamp earliest = UINT64_MAX;
   for (long i = 0; i < RARRAY_LEN(ep->conns); i++) {
     quic_conn_t *c = quic_conn_get(RARRAY_AREF(ep->conns, i));
-    ngtcp2_tstamp t = c->close_deadline != 0 ? c->close_deadline : ngtcp2_conn_get_expiry2(c->conn);
-    if (t < earliest) earliest = t;
+    ngtcp2_tstamp t = c->close_deadline != 0 ? c->close_deadline
+                                             : ngtcp2_conn_get_expiry2(c->conn);
+    if (t < earliest)
+      earliest = t;
   }
   return earliest == UINT64_MAX ? Qnil : ULL2NUM((unsigned long long)earliest);
 }
@@ -736,9 +744,7 @@ quic_endpoint_expiry(VALUE self)
 /* #handle_expiry: run the timers of every connection due, and take out of
    the table those whose closing or draining period is over or that timed
    out. */
-static VALUE
-quic_endpoint_handle_expiry(VALUE self)
-{
+static VALUE quic_endpoint_handle_expiry(VALUE self) {
   quic_endpoint_t *ep = quic_endpoint_get(self);
   ngtcp2_tstamp now = quic_now();
   /* A copy, since connections leave ep->conns along the way. */
@@ -746,16 +752,20 @@ quic_endpoint_handle_expiry(VALUE self)
   for (long i = 0; i < RARRAY_LEN(conns); i++) {
     VALUE conn = RARRAY_AREF(conns, i);
     quic_conn_t *c = quic_conn_get(conn);
-    if (c->endpoint == NULL) continue;
+    if (c->endpoint == NULL)
+      continue;
     if (c->close_deadline != 0) {
-      if (c->close_deadline <= now) quic_endpoint_remove(ep, conn, c);
+      if (c->close_deadline <= now)
+        quic_endpoint_remove(ep, conn, c);
       continue;
     }
-    if (ngtcp2_conn_get_expiry2(c->conn) > now) continue;
+    if (ngtcp2_conn_get_expiry2(c->conn) > now)
+      continue;
 
     c->now = now;
     int rv = ngtcp2_conn_handle_expiry(c->conn, now);
-    if ((rv != 0 || !NIL_P(c->pending_exc)) && quic_endpoint_handle_error(ep, c, rv)) {
+    if ((rv != 0 || !NIL_P(c->pending_exc)) &&
+        quic_endpoint_handle_error(ep, c, rv)) {
       quic_endpoint_remove(ep, conn, c);
     }
   }
@@ -765,9 +775,7 @@ quic_endpoint_handle_expiry(VALUE self)
 
 /* #take_closed: the connections that left the table since the last call,
    in the order they left. */
-static VALUE
-quic_endpoint_take_closed(VALUE self)
-{
+static VALUE quic_endpoint_take_closed(VALUE self) {
   quic_endpoint_t *ep = quic_endpoint_get(self);
   VALUE closed = ep->closed;
   ep->closed = rb_ary_new();
@@ -776,36 +784,29 @@ quic_endpoint_take_closed(VALUE self)
 
 /* #connections: the connections in the table, closing and draining ones
    included. */
-static VALUE
-quic_endpoint_connections(VALUE self)
-{
+static VALUE quic_endpoint_connections(VALUE self) {
   return rb_ary_dup(quic_endpoint_get(self)->conns);
 }
 
 /* #stop_accepting: refuse every new connection from now on with
    CONNECTION_REFUSED. There is no way back. */
-static VALUE
-quic_endpoint_stop_accepting(VALUE self)
-{
+static VALUE quic_endpoint_stop_accepting(VALUE self) {
   quic_endpoint_get(self)->accepting = false;
   return Qnil;
 }
 
 /* #tls_context=: the context new connections are made with. Connections
    already made keep theirs. */
-static VALUE
-quic_endpoint_set_tls_context(VALUE self, VALUE tls_context)
-{
+static VALUE quic_endpoint_set_tls_context(VALUE self, VALUE tls_context) {
   quic_endpoint_t *ep = quic_endpoint_get(self);
   quic_tls_context_get(tls_context);
   ep->tls_context = tls_context;
   return tls_context;
 }
 
-void
-Init_quic_endpoint(VALUE rb_mQUICArg)
-{
-  if (RAND_bytes((uint8_t *)&quic_cid_hash_seed, sizeof(quic_cid_hash_seed)) != 1) {
+void Init_quic_endpoint(VALUE rb_mQUICArg) {
+  if (RAND_bytes((uint8_t *)&quic_cid_hash_seed, sizeof(quic_cid_hash_seed)) !=
+      1) {
     rb_raise(rb_eRuntimeError, "RAND_bytes(CID hash seed) failed");
   }
 
@@ -815,9 +816,14 @@ Init_quic_endpoint(VALUE rb_mQUICArg)
   rb_define_method(rb_cQUICEndpoint, "read_pkt", quic_endpoint_read_pkt, -1);
   rb_define_method(rb_cQUICEndpoint, "write_pkt", quic_endpoint_write_pkt, 0);
   rb_define_method(rb_cQUICEndpoint, "expiry", quic_endpoint_expiry, 0);
-  rb_define_method(rb_cQUICEndpoint, "handle_expiry", quic_endpoint_handle_expiry, 0);
-  rb_define_method(rb_cQUICEndpoint, "take_closed", quic_endpoint_take_closed, 0);
-  rb_define_method(rb_cQUICEndpoint, "connections", quic_endpoint_connections, 0);
-  rb_define_method(rb_cQUICEndpoint, "stop_accepting", quic_endpoint_stop_accepting, 0);
-  rb_define_method(rb_cQUICEndpoint, "tls_context=", quic_endpoint_set_tls_context, 1);
+  rb_define_method(rb_cQUICEndpoint, "handle_expiry",
+                   quic_endpoint_handle_expiry, 0);
+  rb_define_method(rb_cQUICEndpoint, "take_closed", quic_endpoint_take_closed,
+                   0);
+  rb_define_method(rb_cQUICEndpoint, "connections", quic_endpoint_connections,
+                   0);
+  rb_define_method(rb_cQUICEndpoint, "stop_accepting",
+                   quic_endpoint_stop_accepting, 0);
+  rb_define_method(rb_cQUICEndpoint,
+                   "tls_context=", quic_endpoint_set_tls_context, 1);
 }