quic 0.0.2 → 0.0.4

data/ext/quic/connection_common.h

@@ -0,0 +1,226 @@
+#ifndef QUIC_CONNECTION_COMMON_H
+#define QUIC_CONNECTION_COMMON_H 1
+
+#include <stdio.h>
+
+#include "quic.h"
+#include "quic/ext.h"
+#include "tls_context.h"
+
+/* Length of the source connection ID this endpoint picks for itself. */
+#define QUIC_SCID_LEN 8
+
+/* Buffer size for #write_pkt. NGTCP2_MAX_UDP_PAYLOAD_SIZE (1200) is the
+   minimum destlen ngtcp2 accepts. Revisit when PMTUD is enabled (Phase 4+). */
+#define QUIC_WRITE_PKT_BUFLEN NGTCP2_MAX_UDP_PAYLOAD_SIZE
+
+/* A QUIC::Endpoint (endpoint.c). */
+typedef struct quic_endpoint quic_endpoint_t;
+
+/* The C side of a QUIC::Connection::Client or QUIC::Connection::Server. Both
+   classes wrap it with quic_conn_data_type, so stream.c can reach the
+   ngtcp2_conn of either through quic_conn_ptr. Only the constructors
+   (_open / _accept) are class specific. */
+typedef struct {
+  ngtcp2_conn *conn;
+  /* Client only. Referenced by cptls.ptls, which only keeps the pointer, so
+     this has to outlive the ptls_t. */
+  ptls_context_t tls_ctx;
+  /* Server only. The shared context cptls.ptls was made from, holding the
+     certificate chain, the signer and the ALPN list. This connection holds
+     a reference, released in quic_conn_free after the ptls_t. */
+  quic_tls_ctx_t *tls;
+  /* Client only. Referenced by tls_ctx.verify_certificate when verify_mode
+     is :peer. Holds a reference to an X509_STORE, released in
+     quic_conn_free. */
+  ptls_openssl_verify_certificate_t verify_cert;
+  bool verify_cert_initialized;
+  /* 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 */
+  /* 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. */
+  ptls_raw_extension_t tls_exts[2];
+  /* Client only. ALPN list handed to picotls, which keeps the pointers for
+     the whole handshake (unlike SSL_set_alpn_protos, which copies). The
+     entries point into alpn_buf, and both are owned by this struct. */
+  ptls_iovec_t *alpn;
+  size_t alpn_count;
+  uint8_t *alpn_buf;
+  ngtcp2_cid scid;
+  ngtcp2_cid dcid;
+  /* ngtcp2 1.x requires applications to associate an ngtcp2_conn with the
+     TLS object so that crypto callbacks (e.g. add_handshake_data) can recover
+     the conn. picotls carries it in the ptls_t's data pointer, set via
+     ptls_get_data_ptr. The ref must outlive the ptls_t. */
+  ngtcp2_crypto_conn_ref conn_ref;
+  /* Back-reference to the Client or Server Ruby object that owns this
+     struct. ngtcp2 stream callbacks receive a void* user_data equal to this
+     struct, and they look up @streams via owner. We are stored INSIDE owner
+     via TypedData_Wrap_Struct, so owner is guaranteed alive while we exist
+     (no dmark needed). GC.compact may relocate owner, so quic_conn_compact
+     updates this field via rb_gc_location. */
+  VALUE owner;
+  /* An exception raised by Ruby code inside an ngtcp2 callback, caught with
+     rb_protect so that it does not unwind through ngtcp2's frames. #read_pkt,
+     #write_pkt and #handle_expiry re-raise it once ngtcp2 has returned.
+     Qnil when there is none. Marked by quic_conn_data_type's dmark. */
+  VALUE pending_exc;
+  /* The C stream handler registered through the quic_ext_api table
+     (set_stream_handler), or NULL. With a handler the connection makes no
+     QUIC::Stream objects: every stream callback goes to the handler, and
+     #write_pkt pulls stream data from it. handler_owner is marked while the
+     connection lives. */
+  const quic_ext_stream_handler *handler;
+  void *handler_ud;
+  VALUE handler_owner;
+  /* The time #read_pkt, #write_pkt or #handle_expiry read on entry. Handed
+     to the handler as `ts`, since ngtcp2 callbacks receive no time. */
+  ngtcp2_tstamp now;
+  /* The application error the handler left with set_application_error, to
+     close the connection with after it reports a failure. */
+  ngtcp2_ccerr close_error;
+  bool close_error_set;
+  /* Set by the constructor. Decides which peer-initiated streams
+     recv_stream_data queues for #accept_stream. */
+  bool is_server;
+  /* <qlog_dir>/<SCID>.sqlog while ngtcp2 writes qlog to it, else NULL.
+     quic_conn_close_qlog closes it as soon as the connection ends;
+     NGTCP2_QLOG_WRITE_FLAG_FIN, sent by ngtcp2_conn_del, closes one still
+     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,
+     NULL once it has left the table; endpoint_owner is that Endpoint's
+     object, marked so that it outlives the connections it holds. */
+  bool from_endpoint;
+  quic_endpoint_t *endpoint;
+  VALUE endpoint_owner;
+  /* Why the Endpoint closed the connection (Connection#error): nil for a
+     close by the peer, by idle timeout or by #close. */
+  VALUE error;
+  /* When the closing or draining period ends; 0 while the connection is
+     open. */
+  ngtcp2_tstamp close_deadline;
+  /* The CONNECTION_CLOSE packet built on entering the closing period, sent
+     again for packets the peer keeps sending, at most three times what they
+     add up to and with exponential backoff (examples/server.cc). */
+  VALUE closebuf;
+  uint64_t close_bytes_recv;
+  uint64_t close_bytes_sent;
+  uint64_t close_pkts_recv;
+  uint64_t close_next_pkts_recv;
+} quic_conn_t;
+
+extern const rb_data_type_t quic_conn_data_type;
+
+extern ptls_key_exchange_algorithm_t *quic_key_exchanges[];
+extern ptls_cipher_suite_t *quic_cipher_suites[];
+
+/* Allocator for both connection classes. The struct starts zeroed, except
+   its VALUE fields, which start as Qnil. */
+VALUE quic_conn_alloc(VALUE klass);
+
+/* CLOCK_MONOTONIC in ngtcp2's units (nanoseconds). */
+ngtcp2_tstamp quic_now(void);
+
+/* Build the next packet of the connection self (wrapping c) into dest of
+   QUIC_WRITE_PKT_BUFLEN bytes, as #write_pkt does, and store its path in
+   *path. Returns the packet's length, 0 when there is nothing to send, or a
+   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);
+
+/* 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);
+
+/* The exception #read_pkt raises for rv, an error ngtcp2_conn_read_pkt
+   returned: a CryptoError (or CertificateVerifyFailed) with the TLS alert
+   for NGTCP2_ERR_CRYPTO, quic_ngtcp2_error_new(rv) otherwise. */
+VALUE quic_conn_error_new(quic_conn_t *c, int rv);
+
+/* Build a QUIC::Connection::Server of class klass for the client whose
+   first Initial is hd, received on path, with the TLS context tls_context
+   (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,
+                           quic_endpoint_t *ep, VALUE ep_owner);
+
+quic_conn_t *quic_conn_get(VALUE self);
+
+/* The raw ngtcp2_conn of a Client or Server, for stream.c to issue ngtcp2
+   calls (e.g. ngtcp2_conn_shutdown_stream_read) on streams whose @client is
+   that connection. The caller must keep the connection object alive for the
+   duration of the call. */
+ngtcp2_conn *quic_conn_ptr(VALUE owner);
+
+/* ngtcp2_crypto_conn_ref.get_conn for quic_conn_t. */
+ngtcp2_conn *quic_conn_get_conn(ngtcp2_crypto_conn_ref *conn_ref);
+
+void quic_require_binary(VALUE str, const char *name);
+
+/* str must be a binary String holding an AF_INET or AF_INET6 sockaddr of
+   exactly that family's size, as Addrinfo#to_sockaddr makes. ngtcp2 copies
+   an address by its length into storage only as large as sockaddr_in6, so
+   anything longer would overrun it. Raises ArgumentError otherwise. */
+void quic_require_sockaddr(VALUE str, const char *name);
+
+/* Validate a path argument and return it as a String, or Qnil for nil.
+   Accepts a String or anything responding to #to_path, and raises
+   ArgumentError for any other type or a path containing NUL. */
+VALUE quic_path_value(VALUE value, const char *name);
+
+/* Copy alpn_ary, an Array of 1-255 byte Strings, into a list and a buffer
+   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);
+
+/* Copy settings.alpn into memory owned by c (c->alpn / c->alpn_buf). An
+   empty list leaves c->alpn_count at 0. */
+void quic_conn_copy_alpn(quic_conn_t *c, VALUE settings_v);
+
+/* Give the peer back the stream stream_id used up, if it is a
+   bidirectional stream the peer opened, as ngtcp2's examples/server.cc
+   does when such a stream closes. Without this the peer can open only
+   initial_max_streams_bidi streams over the whole connection. */
+void quic_conn_give_back_peer_stream(ngtcp2_conn *conn, int64_t stream_id);
+
+void quic_fill_transport_params(ngtcp2_transport_params *params, VALUE tp);
+void quic_fill_settings(ngtcp2_settings *settings, VALUE st);
+
+/* When settings_v.qlog_dir is set, open <qlog_dir>/<c->scid in hex>.sqlog
+   (as ngtcp2's examples name it) and have ngtcp2 write the connection's
+   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);
+
+/* 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
+   recv_client_initial). */
+void quic_conn_fill_common_callbacks(ngtcp2_callbacks *callbacks);
+
+/* Define the packet I/O, timer, state and stream methods on klass. */
+void quic_conn_define_shared_methods(VALUE klass);
+
+/* The quic_ext_api table (ext_api.c) that quic_ext_get_api hands out. */
+extern const quic_ext_api quic_ext_api_table;
+
+#endif /* QUIC_CONNECTION_COMMON_H */

data/ext/quic/connection_server.c

@@ -0,0 +1,205 @@
+#include "connection_common.h"
+#include "endpoint.h"
+
+#include <openssl/rand.h>
+
+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) {
+  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) {
+  VALUE self = quic_conn_alloc(klass);
+  quic_conn_t *c = quic_conn_get(self);
+  c->owner = self;
+  c->is_server = true;
+  /* Set before ngtcp2_conn_server_new, whose callbacks may already look for
+     the Endpoint. */
+  if (ep != NULL) {
+    c->from_endpoint = true;
+    c->endpoint = ep;
+    c->endpoint_owner = ep_owner;
+  }
+
+  /* The reference taken here keeps the context alive until quic_conn_free,
+     whatever happens to the QUIC::TLSContext object. */
+  c->tls = quic_tls_context_get(tls_context);
+  quic_tls_ctx_ref(c->tls);
+
+  c->dcid = hd->scid;
+  c->scid.datalen = QUIC_SCID_LEN;
+  if (RAND_bytes(c->scid.data, QUIC_SCID_LEN) != 1) {
+    rb_raise(rb_eRuntimeError, "RAND_bytes(scid) failed");
+  }
+
+  ngtcp2_transport_params params;
+  quic_fill_transport_params(&params, transport_params);
+  /* Without Retry, the original DCID is the one in this first packet. The
+     handshake fails if it is missing. */
+  params.original_dcid = hd->dcid;
+  params.original_dcid_present = 1;
+  /* 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");
+    }
+    params.stateless_reset_token_present = 1;
+  }
+
+  /* quic_conn_alloc already zeroed the struct, but calling ctx_init keeps
+     the ngtcp2-side initialization explicit, as in _open. */
+  ngtcp2_crypto_picotls_ctx_init(&c->cptls);
+
+  ngtcp2_callbacks callbacks;
+  quic_conn_fill_common_callbacks(&callbacks);
+  callbacks.recv_client_initial = ngtcp2_crypto_recv_client_initial_cb;
+
+  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);
+  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. */
+  *ptls_get_data_ptr(c->cptls.ptls) = &c->conn_ref;
+  /* [0] carries the QUIC transport parameters, filled in by ngtcp2; [1]
+     terminates the list. */
+  c->tls_exts[0].type = UINT16_MAX;
+  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) {
+    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);
+
+  /* Stream registry and accept queue, as in _open. The accept queue holds
+     client-initiated streams here. */
+  rb_ivar_set(self, rb_intern("@streams"), rb_hash_new());
+  rb_ivar_set(self, rb_intern("@accept_queue"), rb_ary_new());
+
+  return self;
+}
+
+/* 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) {
+  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");
+  }
+
+  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, "
+             "certificate_path, private_key_path, transport_params, settings");
+  }
+
+  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");
+
+  const uint8_t *data = (const uint8_t *)RSTRING_PTR(initial_packet);
+  size_t datalen = (size_t)RSTRING_LEN(initial_packet);
+
+  /* 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();
+
+  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)",
+             (unsigned int)vc.version);
+  }
+  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();
+
+  /* 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));
+
+  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,
+  };
+
+  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);
+  rb_define_alloc_func(rb_cQUICConnectionServer, quic_conn_alloc);
+  rb_define_singleton_method(rb_cQUICConnectionServer, "_accept",
+                             quic_server_accept, -1);
+  quic_conn_define_shared_methods(rb_cQUICConnectionServer);
+}