add optional qlogging to quiche

Cargo.toml

@@ -62,6 +62,7 @@ libc = "0.2"
 ring = "0.16"
 criterion = { version = "0.3", optional = true }
 lazy_static = "1"
+qlog = { version = "0.2", optional = true }
 
 [target."cfg(windows)".dependencies]
 winapi = { version = "0.3", features = ["wincrypt"] }

clippy.toml

@@ -1 +1 @@
-cognitive-complexity-threshold = 70
+cognitive-complexity-threshold = 72

include/quiche.h

@@ -214,6 +214,10 @@ quiche_conn *quiche_conn_new_with_tls(const uint8_t *scid, size_t scid_len,
                                       quiche_config *config, void *ssl,
                                       bool is_server);
 
+// Enables qlog to the specified file descriptor. Unix only.
+void quiche_conn_set_qlog_fd(quiche_conn *conn, int fd, const char * log_title,
+                             const char * log_desc);
+
 // Processes QUIC packets received from the peer.
 ssize_t quiche_conn_recv(quiche_conn *conn, uint8_t *buf, size_t buf_len);
 

src/ffi.rs

@@ -29,6 +29,9 @@ use std::ptr;
 use std::slice;
 use std::sync::atomic;
 
+#[cfg(all(unix, feature = "qlog"))]
+use std::os::unix::io::FromRawFd;
+
 use libc::c_char;
 use libc::c_int;
 use libc::c_void;
@@ -231,6 +234,25 @@ pub extern fn quiche_config_set_cc_algorithm(
     config.set_cc_algorithm(algo);
 }
 
+#[no_mangle]
+#[cfg(all(unix, feature = "qlog"))]
+pub extern fn quiche_conn_set_qlog_fd(
+    conn: &mut Connection, fd: c_int, log_title: *const c_char,
+    log_desc: *const c_char,
+) {
+    let f = unsafe { std::fs::File::from_raw_fd(fd) };
+    let writer = std::io::BufWriter::new(f);
+
+    let title = unsafe { ffi::CStr::from_ptr(log_title).to_str().unwrap() };
+    let description = unsafe { ffi::CStr::from_ptr(log_desc).to_str().unwrap() };
+
+    conn.set_qlog(
+        std::boxed::Box::new(writer),
+        title.to_string(),
+        format!("{} id={}", description, conn.trace_id),
+    );
+}
+
 #[no_mangle]
 pub extern fn quiche_config_free(config: *mut Config) {
     unsafe { Box::from_raw(config) };

src/frame.rs

@@ -689,6 +689,154 @@ impl Frame {
             _ => true,
         }
     }
+
+    #[cfg(feature = "qlog")]
+    pub fn to_qlog(&self) -> qlog::QuicFrame {
+        match self {
+            Frame::Padding { .. } => qlog::QuicFrame::padding(),
+
+            Frame::Ping { .. } => qlog::QuicFrame::ping(),
+
+            Frame::ACK { ack_delay, ranges } => {
+                let ack_ranges =
+                    ranges.iter().map(|r| (r.start, r.end - 1)).collect();
+                qlog::QuicFrame::ack(
+                    Some(ack_delay.to_string()),
+                    Some(ack_ranges),
+                    None,
+                    None,
+                    None,
+                )
+            },
+
+            Frame::ResetStream {
+                stream_id,
+                error_code,
+                final_size,
+            } => qlog::QuicFrame::reset_stream(
+                stream_id.to_string(),
+                *error_code,
+                final_size.to_string(),
+            ),
+
+            Frame::StopSending {
+                stream_id,
+                error_code,
+            } =>
+                qlog::QuicFrame::stop_sending(stream_id.to_string(), *error_code),
+
+            Frame::Crypto { data } => qlog::QuicFrame::crypto(
+                data.off().to_string(),
+                data.len().to_string(),
+            ),
+
+            Frame::NewToken { token } => qlog::QuicFrame::new_token(
+                token.len().to_string(),
+                "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                    .to_string(),
+            ),
+
+            Frame::Stream { stream_id, data } => qlog::QuicFrame::stream(
+                stream_id.to_string(),
+                data.off().to_string(),
+                data.len().to_string(),
+                data.fin(),
+                None,
+            ),
+
+            Frame::MaxData { max } => qlog::QuicFrame::max_data(max.to_string()),
+
+            Frame::MaxStreamData { stream_id, max } =>
+                qlog::QuicFrame::max_stream_data(
+                    stream_id.to_string(),
+                    max.to_string(),
+                ),
+
+            Frame::MaxStreamsBidi { max } => qlog::QuicFrame::max_streams(
+                qlog::StreamType::Bidirectional,
+                max.to_string(),
+            ),
+
+            Frame::MaxStreamsUni { max } => qlog::QuicFrame::max_streams(
+                qlog::StreamType::Unidirectional,
+                max.to_string(),
+            ),
+
+            Frame::DataBlocked { limit } =>
+                qlog::QuicFrame::data_blocked(limit.to_string()),
+
+            Frame::StreamDataBlocked { stream_id, limit } =>
+                qlog::QuicFrame::stream_data_blocked(
+                    stream_id.to_string(),
+                    limit.to_string(),
+                ),
+
+            Frame::StreamsBlockedBidi { limit } =>
+                qlog::QuicFrame::streams_blocked(
+                    qlog::StreamType::Bidirectional,
+                    limit.to_string(),
+                ),
+
+            Frame::StreamsBlockedUni { limit } =>
+                qlog::QuicFrame::streams_blocked(
+                    qlog::StreamType::Unidirectional,
+                    limit.to_string(),
+                ),
+
+            Frame::NewConnectionId {
+                seq_num,
+                retire_prior_to,
+                conn_id,
+                ..
+            } => qlog::QuicFrame::new_connection_id(
+                seq_num.to_string(),
+                retire_prior_to.to_string(),
+                conn_id.len() as u64,
+                "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                    .to_string(),
+                "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                    .to_string(),
+            ),
+
+            Frame::RetireConnectionId { seq_num } =>
+                qlog::QuicFrame::retire_connection_id(seq_num.to_string()),
+
+            Frame::PathChallenge { .. } => qlog::QuicFrame::path_challenge(Some(
+                "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                    .to_string(),
+            )),
+
+            Frame::PathResponse { .. } => qlog::QuicFrame::path_response(Some(
+                "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                    .to_string(),
+            )),
+
+            Frame::ConnectionClose {
+                error_code, reason, ..
+            } => qlog::QuicFrame::connection_close(
+                qlog::ErrorSpace::TransportError,
+                *error_code,
+                *error_code,
+                String::from_utf8(reason.clone()).unwrap(),
+                Some(
+                    "TODO: https://github.com/quiclog/internet-drafts/issues/36"
+                        .to_string(),
+                ),
+            ),
+
+            Frame::ApplicationClose { error_code, reason } =>
+                qlog::QuicFrame::connection_close(
+                    qlog::ErrorSpace::ApplicationError,
+                    *error_code,
+                    *error_code,
+                    String::from_utf8(reason.clone()).unwrap(),
+                    None, /* Application variant of the frame has no trigger
+                           * frame type */
+                ),
+
+            _ => qlog::QuicFrame::unknown(std::u64::MAX),
+        }
+    }
 }
 
 impl std::fmt::Debug for Frame {