quic 0.0.3 → 0.0.4

data/ext/quic/connection_common.h

@@ -38,7 +38,7 @@ typedef struct {
   /* Filled by quic_override_verify_cb during the handshake so that a failed
      read_pkt can raise CertificateVerifyFailed with the X509 error. */
   bool verify_failed;
-  int verify_result;  /* X509_V_ERR_*, 0 when the server sent no certificate */
+  int verify_result; /* X509_V_ERR_*, 0 when the server sent no certificate */
   /* The TLS native handle handed to ngtcp2 (&cptls, not cptls.ptls). */
   ngtcp2_crypto_picotls_ctx cptls;
   /* [0]: QUIC transport params, filled in by ngtcp2; [1]: terminator. */
@@ -87,8 +87,9 @@ typedef struct {
      recv_stream_data queues for #accept_stream. */
   bool is_server;
   /* <qlog_dir>/<SCID>.sqlog while ngtcp2 writes qlog to it, else NULL.
-     Closed on NGTCP2_QLOG_WRITE_FLAG_FIN, which ngtcp2_conn_del sends at
-     the latest. */
+     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
+     open when the connection is freed. */
   FILE *qlog;
   /* The rest is for a connection a QUIC::Endpoint made, and stays zero (nil)
      otherwise. endpoint is the Endpoint whose table holds this connection,
@@ -130,14 +131,14 @@ ngtcp2_tstamp quic_now(void);
    *path. Returns the packet's length, 0 when there is nothing to send, or a
    negative ngtcp2 error. Never raises for the connection's own failures: an
    exception from a Ruby callback is left in c->pending_exc. */
-ngtcp2_ssize quic_conn_write_pkt_raw(VALUE self, quic_conn_t *c, ngtcp2_path *path,
-                                     uint8_t *dest);
+ngtcp2_ssize quic_conn_write_pkt_raw(VALUE self, quic_conn_t *c,
+                                     ngtcp2_path *path, uint8_t *dest);
 
 /* Feed one datagram to the connection, as #read_pkt does, and return what
    ngtcp2_conn_read_pkt returned. Like quic_conn_write_pkt_raw, it leaves an
    exception from a Ruby callback in c->pending_exc. */
-int quic_conn_read_pkt_raw(quic_conn_t *c, const ngtcp2_path *path, const uint8_t *data,
-                           size_t datalen);
+int quic_conn_read_pkt_raw(quic_conn_t *c, const ngtcp2_path *path,
+                           const uint8_t *data, size_t datalen);
 
 /* The exception #read_pkt raises for rv, an error ngtcp2_conn_read_pkt
    returned: a CryptoError (or CertificateVerifyFailed) with the TLS alert
@@ -149,8 +150,9 @@ VALUE quic_conn_error_new(quic_conn_t *c, int rv);
    (a QUIC::TLSContext). ep is the Endpoint that will hold it (its object
    ep_owner), or NULL for Server.accept. Raises if ngtcp2 or picotls cannot
    set the connection up. */
-VALUE quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *path,
-                           VALUE tls_context, VALUE transport_params, VALUE settings_v,
+VALUE quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd,
+                           const ngtcp2_path *path, VALUE tls_context,
+                           VALUE transport_params, VALUE settings_v,
                            quic_endpoint_t *ep, VALUE ep_owner);
 
 quic_conn_t *quic_conn_get(VALUE self);
@@ -181,7 +183,8 @@ VALUE quic_path_value(VALUE value, const char *name);
    the list's entries point into. Both are stored in *list and *buf as soon
    as they are allocated, for the caller to release with xfree even when
    this raises. An empty Array allocates nothing and sets *count to 0. */
-void quic_copy_alpn(VALUE alpn_ary, ptls_iovec_t **list, size_t *count, uint8_t **buf);
+void quic_copy_alpn(VALUE alpn_ary, ptls_iovec_t **list, size_t *count,
+                    uint8_t **buf);
 
 /* Copy settings.alpn into memory owned by c (c->alpn / c->alpn_buf). An
    empty list leaves c->alpn_count at 0. */
@@ -201,7 +204,13 @@ void quic_fill_settings(ngtcp2_settings *settings, VALUE st);
    qlog there. c->scid must be set. A file that cannot be opened only goes
    without qlog: QUIC::Settings#check_qlog_dir already caught a wrong
    directory when the connection or Endpoint was set up. */
-void quic_conn_open_qlog(quic_conn_t *c, VALUE settings_v, ngtcp2_settings *settings);
+void quic_conn_open_qlog(quic_conn_t *c, VALUE settings_v,
+                         ngtcp2_settings *settings);
+
+/* Close c's qlog file, if open. Called wherever the connection ends, so
+   that the file does not wait for GC; what ngtcp2 logs afterwards goes
+   nowhere. */
+void quic_conn_close_qlog(quic_conn_t *c);
 
 /* Zero *callbacks and fill in everything both endpoints share. The caller
    adds the endpoint specific ones (client_initial / recv_retry, or

data/ext/quic/connection_server.c

@@ -7,17 +7,15 @@ NORETURN(static void quic_server_raise_unacceptable(void));
 
 /* The first datagram cannot start a connection. code stays nil: this is
    _accept's own verdict, not an ngtcp2 error passed through. */
-static void
-quic_server_raise_unacceptable(void)
-{
+static void quic_server_raise_unacceptable(void) {
   rb_raise(rb_eQUICErrorProto, "not an acceptable Initial packet");
 }
 
 VALUE
-quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *path,
-                     VALUE tls_context, VALUE transport_params, VALUE settings_v,
-                     quic_endpoint_t *ep, VALUE ep_owner)
-{
+quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd,
+                     const ngtcp2_path *path, VALUE tls_context,
+                     VALUE transport_params, VALUE settings_v,
+                     quic_endpoint_t *ep, VALUE ep_owner) {
   VALUE self = quic_conn_alloc(klass);
   quic_conn_t *c = quic_conn_get(self);
   c->owner = self;
@@ -50,8 +48,10 @@ quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *pa
   /* Only an Endpoint can answer with a Stateless Reset, for a CID it no
      longer knows, so only its connections announce a token. */
   if (ep != NULL) {
-    if (quic_endpoint_generate_reset_token(ep, params.stateless_reset_token, &c->scid) != 0) {
-      rb_raise(rb_eRuntimeError, "ngtcp2_crypto_generate_stateless_reset_token failed");
+    if (quic_endpoint_generate_reset_token(ep, params.stateless_reset_token,
+                                           &c->scid) != 0) {
+      rb_raise(rb_eRuntimeError,
+               "ngtcp2_crypto_generate_stateless_reset_token failed");
     }
     params.stateless_reset_token_present = 1;
   }
@@ -66,19 +66,23 @@ quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *pa
 
   ngtcp2_settings settings;
   quic_fill_settings(&settings, settings_v);
+  /* Every raise below closes it first. */
   quic_conn_open_qlog(c, settings_v, &settings);
 
   c->conn_ref.get_conn = quic_conn_get_conn;
   c->conn_ref.user_data = c;
 
-  int rv = ngtcp2_conn_server_new(&c->conn, &c->dcid, &c->scid, path, hd->version,
-                                  &callbacks, &settings, &params, NULL, c);
+  int rv =
+      ngtcp2_conn_server_new(&c->conn, &c->dcid, &c->scid, path, hd->version,
+                             &callbacks, &settings, &params, NULL, c);
   if (rv != 0) {
+    quic_conn_close_qlog(c);
     quic_raise_ngtcp2_error(rv);
   }
 
   c->cptls.ptls = ptls_server_new(&c->tls->ctx);
   if (c->cptls.ptls == NULL) {
+    quic_conn_close_qlog(c);
     rb_raise(rb_eRuntimeError, "ptls_server_new failed");
   }
   /* Let ngtcp2's crypto callbacks resolve the ngtcp2_conn from the ptls_t. */
@@ -89,7 +93,9 @@ quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *pa
   c->tls_exts[1].type = UINT16_MAX;
   c->cptls.handshake_properties.additional_extensions = c->tls_exts;
   if (ngtcp2_crypto_picotls_configure_server_session(&c->cptls) != 0) {
-    rb_raise(rb_eRuntimeError, "ngtcp2_crypto_picotls_configure_server_session failed");
+    quic_conn_close_qlog(c);
+    rb_raise(rb_eRuntimeError,
+             "ngtcp2_crypto_picotls_configure_server_session failed");
   }
 
   ngtcp2_conn_set_tls_native_handle(c->conn, &c->cptls);
@@ -105,35 +111,41 @@ quic_server_conn_new(VALUE klass, const ngtcp2_pkt_hd *hd, const ngtcp2_path *pa
 /* Build a server connection from the first datagram a client sent. Only the
    ngtcp2_conn and the TLS session are set up here; QUIC::Connection::Server
    .accept feeds that datagram to #read_pkt afterwards. */
-static VALUE
-quic_server_accept(int argc, VALUE *argv, VALUE klass)
-{
+static VALUE quic_server_accept(int argc, VALUE *argv, VALUE klass) {
   VALUE opts = Qnil;
   rb_scan_args(argc, argv, "0:", &opts);
   if (NIL_P(opts)) {
-    rb_raise(rb_eArgError,
-             "missing keywords: initial_packet, local_sockaddr, remote_sockaddr, "
-             "certificate_path, private_key_path, transport_params, settings");
+    rb_raise(
+        rb_eArgError,
+        "missing keywords: initial_packet, local_sockaddr, remote_sockaddr, "
+        "certificate_path, private_key_path, transport_params, settings");
   }
 
-  VALUE initial_packet   = rb_hash_aref(opts, ID2SYM(rb_intern("initial_packet")));
-  VALUE local_sockaddr   = rb_hash_aref(opts, ID2SYM(rb_intern("local_sockaddr")));
-  VALUE remote_sockaddr  = rb_hash_aref(opts, ID2SYM(rb_intern("remote_sockaddr")));
-  VALUE certificate_path = rb_hash_aref(opts, ID2SYM(rb_intern("certificate_path")));
-  VALUE private_key_path = rb_hash_aref(opts, ID2SYM(rb_intern("private_key_path")));
-  VALUE transport_params = rb_hash_aref(opts, ID2SYM(rb_intern("transport_params")));
-  VALUE settings_v       = rb_hash_aref(opts, ID2SYM(rb_intern("settings")));
-
-  if (NIL_P(initial_packet) || NIL_P(local_sockaddr) || NIL_P(remote_sockaddr) ||
-      NIL_P(certificate_path) || NIL_P(private_key_path) ||
-      NIL_P(transport_params) || NIL_P(settings_v)) {
+  VALUE initial_packet =
+      rb_hash_aref(opts, ID2SYM(rb_intern("initial_packet")));
+  VALUE local_sockaddr =
+      rb_hash_aref(opts, ID2SYM(rb_intern("local_sockaddr")));
+  VALUE remote_sockaddr =
+      rb_hash_aref(opts, ID2SYM(rb_intern("remote_sockaddr")));
+  VALUE certificate_path =
+      rb_hash_aref(opts, ID2SYM(rb_intern("certificate_path")));
+  VALUE private_key_path =
+      rb_hash_aref(opts, ID2SYM(rb_intern("private_key_path")));
+  VALUE transport_params =
+      rb_hash_aref(opts, ID2SYM(rb_intern("transport_params")));
+  VALUE settings_v = rb_hash_aref(opts, ID2SYM(rb_intern("settings")));
+
+  if (NIL_P(initial_packet) || NIL_P(local_sockaddr) ||
+      NIL_P(remote_sockaddr) || NIL_P(certificate_path) ||
+      NIL_P(private_key_path) || NIL_P(transport_params) || NIL_P(settings_v)) {
     rb_raise(rb_eArgError,
-             "all keywords required: initial_packet, local_sockaddr, remote_sockaddr, "
+             "all keywords required: initial_packet, local_sockaddr, "
+             "remote_sockaddr, "
              "certificate_path, private_key_path, transport_params, settings");
   }
 
-  quic_require_binary(initial_packet,  "initial_packet");
-  quic_require_sockaddr(local_sockaddr,  "local_sockaddr");
+  quic_require_binary(initial_packet, "initial_packet");
+  quic_require_sockaddr(local_sockaddr, "local_sockaddr");
   quic_require_sockaddr(remote_sockaddr, "remote_sockaddr");
   certificate_path = quic_path_value(certificate_path, "certificate_path");
   private_key_path = quic_path_value(private_key_path, "private_key_path");
@@ -143,44 +155,51 @@ quic_server_accept(int argc, VALUE *argv, VALUE klass)
 
   /* ngtcp2_pkt_decode_version_cid asserts datalen > 0, and ngtcp2 is built
      with assertions enabled, so an empty datagram would abort the process. */
-  if (datalen == 0) quic_server_raise_unacceptable();
+  if (datalen == 0)
+    quic_server_raise_unacceptable();
 
   ngtcp2_version_cid vc;
   int rv = ngtcp2_pkt_decode_version_cid(&vc, data, datalen, QUIC_SCID_LEN);
   if (rv == NGTCP2_ERR_VERSION_NEGOTIATION) {
     rb_raise(rb_eQUICErrorProto,
-             "unsupported QUIC version 0x%08x (Version Negotiation is not implemented)",
+             "unsupported QUIC version 0x%08x (Version Negotiation is not "
+             "implemented)",
              (unsigned int)vc.version);
   }
-  if (rv != 0) quic_server_raise_unacceptable();
+  if (rv != 0)
+    quic_server_raise_unacceptable();
 
   /* Unlike vc, hd holds the CIDs by value, so it outlives the packet buffer.
      A token (address validation) is accepted without checking it: no Retry
      is ever sent, so a well-behaved client does not send one. */
   ngtcp2_pkt_hd hd;
-  if (ngtcp2_accept(&hd, data, datalen) != 0) quic_server_raise_unacceptable();
+  if (ngtcp2_accept(&hd, data, datalen) != 0)
+    quic_server_raise_unacceptable();
 
   /* A context of this connection's own, as one made by
      QUIC::TLSContext.server. verify_mode, ca_file and ca_path are not read,
      since no client certificate is requested. */
-  VALUE tls_context = quic_tls_context_server_new(
-    certificate_path, private_key_path, rb_funcall(settings_v, rb_intern("alpn"), 0));
+  VALUE tls_context =
+      quic_tls_context_server_new(certificate_path, private_key_path,
+                                  rb_funcall(settings_v, rb_intern("alpn"), 0));
 
   ngtcp2_path path = {
-    {(struct sockaddr *)RSTRING_PTR(local_sockaddr),  (ngtcp2_socklen)RSTRING_LEN(local_sockaddr)},
-    {(struct sockaddr *)RSTRING_PTR(remote_sockaddr), (ngtcp2_socklen)RSTRING_LEN(remote_sockaddr)},
-    NULL,
+      {(struct sockaddr *)RSTRING_PTR(local_sockaddr),
+       (ngtcp2_socklen)RSTRING_LEN(local_sockaddr)},
+      {(struct sockaddr *)RSTRING_PTR(remote_sockaddr),
+       (ngtcp2_socklen)RSTRING_LEN(remote_sockaddr)},
+      NULL,
   };
 
-  return quic_server_conn_new(klass, &hd, &path, tls_context, transport_params, settings_v,
-                              NULL, Qnil);
+  return quic_server_conn_new(klass, &hd, &path, tls_context, transport_params,
+                              settings_v, NULL, Qnil);
 }
 
-void
-Init_quic_connection_server(VALUE rb_mQUICConnectionArg)
-{
-  rb_cQUICConnectionServer = rb_define_class_under(rb_mQUICConnectionArg, "Server", rb_cObject);
+void Init_quic_connection_server(VALUE rb_mQUICConnectionArg) {
+  rb_cQUICConnectionServer =
+      rb_define_class_under(rb_mQUICConnectionArg, "Server", rb_cObject);
   rb_define_alloc_func(rb_cQUICConnectionServer, quic_conn_alloc);
-  rb_define_singleton_method(rb_cQUICConnectionServer, "_accept", quic_server_accept, -1);
+  rb_define_singleton_method(rb_cQUICConnectionServer, "_accept",
+                             quic_server_accept, -1);
   quic_conn_define_shared_methods(rb_cQUICConnectionServer);
 }