diff options
Diffstat (limited to 'third_party/rust/qlog/src')
| -rw-r--r-- | third_party/rust/qlog/src/event.rs | 988 | ||||
| -rw-r--r-- | third_party/rust/qlog/src/lib.rs | 2970 |
2 files changed, 3958 insertions, 0 deletions
diff --git a/third_party/rust/qlog/src/event.rs b/third_party/rust/qlog/src/event.rs new file mode 100644 index 0000000000..5748bf82d5 --- /dev/null +++ b/third_party/rust/qlog/src/event.rs @@ -0,0 +1,988 @@ +// Copyright (C) 2020, Cloudflare, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//! Module-defined Event and functions to work with qlog data structures. +//! +//! The Qlog data structures are very flexible, which makes working with them +//! liable to simple semantic errors. This module provides some helper functions +//! that focus on creating valid types, while also reducing some of the +//! verbosity of using the raw data structures. + +use super::*; + +/// A representation of qlog events that couple EventCategory, EventType and +/// EventData. +/// +/// Functions are provided to help construct valid events. Most events consist +/// of several optional fields, so minimal versions of these functions are +/// provided, which accept only mandatory qlog parameters. Minimal functions are +/// identified by a `_min` suffix. +#[derive(Clone)] +pub struct Event { + pub category: EventCategory, + pub ty: EventType, + pub data: EventData, +} + +#[allow(clippy::too_many_arguments)] +impl Event { + // Connectivity events. + + /// Returns: + /// * `EventCategory`=`Connectivity` + /// * `EventType`=`ConnectivityEventType::ServerListening` + /// * `EventData`=`ServerListening`. + pub fn server_listening( + ip_v4: Option<String>, ip_v6: Option<String>, port_v4: u64, port_v6: u64, + quic_versions: Option<Vec<String>>, alpn_values: Option<Vec<String>>, + stateless_reset_required: Option<bool>, + ) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::ConnectivityEventType( + ConnectivityEventType::ServerListening, + ), + data: EventData::ServerListening { + ip_v4, + ip_v6, + port_v4, + port_v6, + quic_versions, + alpn_values, + stateless_reset_required, + }, + } + } + + pub fn server_listening_min(port_v4: u64, port_v6: u64) -> Self { + Event::server_listening(None, None, port_v4, port_v6, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Connectivity` + /// * `EventType`=`ConnectivityEventType::ConnectionStarted` + /// * `EventData`=`ConnectionStarted`. + pub fn connection_started( + ip_version: String, src_ip: String, dst_ip: String, + protocol: Option<String>, src_port: u64, dst_port: u64, + quic_version: Option<String>, src_cid: Option<String>, + dst_cid: Option<String>, + ) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::ConnectivityEventType( + ConnectivityEventType::ConnectionStarted, + ), + data: EventData::ConnectionStarted { + ip_version, + src_ip, + dst_ip, + protocol, + src_port, + dst_port, + quic_version, + src_cid, + dst_cid, + }, + } + } + + pub fn connection_started_min( + ip_version: String, src_ip: String, dst_ip: String, src_port: u64, + dst_port: u64, + ) -> Self { + Event::connection_started( + ip_version, src_ip, dst_ip, None, src_port, dst_port, None, None, + None, + ) + } + + /// Returns: + /// * `EventCategory`=`Connectivity` + /// * `EventType`=`ConnectivityEventType::ConnectionIdUpdated` + /// * `EventData`=`ConnectionIdUpdated`. + pub fn connection_id_updated( + src_old: Option<String>, src_new: Option<String>, + dst_old: Option<String>, dst_new: Option<String>, + ) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::ConnectivityEventType( + ConnectivityEventType::ConnectionIdUpdated, + ), + data: EventData::ConnectionIdUpdated { + src_old, + src_new, + dst_old, + dst_new, + }, + } + } + + pub fn connection_id_updated_min() -> Self { + Event::connection_id_updated(None, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Connectivity` + /// * `EventType`=`ConnectivityEventType::SpinBitUpdated` + /// * `EventData`=`SpinBitUpdated`. + pub fn spinbit_updated(state: bool) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::ConnectivityEventType( + ConnectivityEventType::SpinBitUpdated, + ), + data: EventData::SpinBitUpdated { state }, + } + } + + /// Returns: + /// * `EventCategory`=`Connectivity` + /// * `EventType`=`ConnectivityEventType::ConnectionState` + /// * `EventData`=`ConnectionState`. + pub fn connection_state_updated( + old: Option<ConnectionState>, new: ConnectionState, + ) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::ConnectivityEventType( + ConnectivityEventType::ConnectionStateUpdated, + ), + data: EventData::ConnectionStateUpdated { old, new }, + } + } + + pub fn connection_state_updated_min(new: ConnectionState) -> Self { + Event::connection_state_updated(None, new) + } + + // Transport events. + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::ParametersSet` + /// * `EventData`=`ParametersSet`. + pub fn transport_parameters_set( + owner: Option<TransportOwner>, resumption_allowed: Option<bool>, + early_data_enabled: Option<bool>, alpn: Option<String>, + version: Option<String>, tls_cipher: Option<String>, + original_connection_id: Option<String>, + stateless_reset_token: Option<String>, + disable_active_migration: Option<bool>, idle_timeout: Option<u64>, + max_packet_size: Option<u64>, ack_delay_exponent: Option<u64>, + max_ack_delay: Option<u64>, active_connection_id_limit: Option<u64>, + initial_max_data: Option<String>, + initial_max_stream_data_bidi_local: Option<String>, + initial_max_stream_data_bidi_remote: Option<String>, + initial_max_stream_data_uni: Option<String>, + initial_max_streams_bidi: Option<String>, + initial_max_streams_uni: Option<String>, + preferred_address: Option<PreferredAddress>, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::ParametersSet), + data: EventData::TransportParametersSet { + owner, + + resumption_allowed, + early_data_enabled, + alpn, + version, + tls_cipher, + + original_connection_id, + stateless_reset_token, + disable_active_migration, + + idle_timeout, + max_packet_size, + ack_delay_exponent, + max_ack_delay, + active_connection_id_limit, + + initial_max_data, + initial_max_stream_data_bidi_local, + initial_max_stream_data_bidi_remote, + initial_max_stream_data_uni, + initial_max_streams_bidi, + initial_max_streams_uni, + + preferred_address, + }, + } + } + + pub fn transport_parameters_set_min() -> Self { + Event::transport_parameters_set( + None, None, None, None, None, None, None, None, None, None, None, + None, None, None, None, None, None, None, None, None, None, + ) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::DatagramsReceived` + /// * `EventData`=`DatagramsReceived`. + pub fn datagrams_received( + count: Option<u64>, byte_length: Option<u64>, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType( + TransportEventType::DatagramsReceived, + ), + data: EventData::DatagramsReceived { count, byte_length }, + } + } + + pub fn datagrams_received_min() -> Self { + Event::datagrams_received(None, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::DatagramsSent` + /// * `EventData`=`DatagramsSent`. + pub fn datagrams_sent(count: Option<u64>, byte_length: Option<u64>) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::DatagramsSent), + data: EventData::DatagramsSent { count, byte_length }, + } + } + + pub fn datagrams_sent_min() -> Self { + Event::datagrams_sent(None, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::DatagramDropped` + /// * `EventData`=`DatagramDropped`. + pub fn datagram_dropped(byte_length: Option<u64>) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType( + TransportEventType::DatagramDropped, + ), + data: EventData::DatagramDropped { byte_length }, + } + } + + pub fn datagram_dropped_min() -> Self { + Event::datagram_dropped(None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::PacketReceived` + /// * `EventData`=`PacketReceived`. + pub fn packet_received( + packet_type: PacketType, header: PacketHeader, + frames: Option<Vec<QuicFrame>>, is_coalesced: Option<bool>, + raw_encrypted: Option<String>, raw_decrypted: Option<String>, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::PacketReceived), + data: EventData::PacketReceived { + packet_type, + header, + frames, + + is_coalesced, + + raw_encrypted, + raw_decrypted, + }, + } + } + + pub fn packet_received_min( + packet_type: PacketType, header: PacketHeader, + ) -> Self { + Event::packet_received(packet_type, header, None, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::PacketSent` + /// * `EventData`=`PacketSent`. + pub fn packet_sent( + packet_type: PacketType, header: PacketHeader, + frames: Option<Vec<QuicFrame>>, is_coalesced: Option<bool>, + raw_encrypted: Option<String>, raw_decrypted: Option<String>, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::PacketSent), + data: EventData::PacketSent { + packet_type, + header, + frames, + + is_coalesced, + + raw_encrypted, + raw_decrypted, + }, + } + } + + pub fn packet_sent_min( + packet_type: PacketType, header: PacketHeader, + frames: Option<Vec<QuicFrame>>, + ) -> Self { + Event::packet_sent(packet_type, header, frames, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::PacketDropped` + /// * `EventData`=`PacketDropped`. + pub fn packet_dropped( + packet_type: Option<PacketType>, packet_size: Option<u64>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::PacketDropped), + data: EventData::PacketDropped { + packet_type, + packet_size, + raw, + }, + } + } + + pub fn packet_dropped_min() -> Self { + Event::packet_dropped(None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::PacketBuffered` + /// * `EventData`=`PacketBuffered`. + pub fn packet_buffered( + packet_type: PacketType, packet_number: String, + ) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType(TransportEventType::PacketBuffered), + data: EventData::PacketBuffered { + packet_type, + packet_number, + }, + } + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::StreamStateUpdated` + /// * `EventData`=`StreamStateUpdated`. + pub fn stream_state_updated( + stream_id: String, stream_type: Option<StreamType>, + old: Option<StreamState>, new: StreamState, + stream_side: Option<StreamSide>, + ) -> Self { + Event { + category: EventCategory::Connectivity, + ty: EventType::TransportEventType( + TransportEventType::StreamStateUpdated, + ), + data: EventData::StreamStateUpdated { + stream_id, + stream_type, + old, + new, + stream_side, + }, + } + } + + pub fn stream_state_updated_min(stream_id: String, new: StreamState) -> Self { + Event::stream_state_updated(stream_id, None, None, new, None) + } + + /// Returns: + /// * `EventCategory`=`Transport` + /// * `EventType`=`TransportEventType::FramesProcessed` + /// * `EventData`=`FramesProcessed`. + pub fn frames_processed(frames: Vec<QuicFrame>) -> Self { + Event { + category: EventCategory::Transport, + ty: EventType::TransportEventType( + TransportEventType::FramesProcessed, + ), + data: EventData::FramesProcessed { frames }, + } + } + + // Recovery events. + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::ParametersSet` + /// * `EventData`=`RecoveryParametersSet`. + pub fn recovery_parameters_set( + reordering_threshold: Option<u64>, time_threshold: Option<u64>, + timer_granularity: Option<u64>, initial_rtt: Option<u64>, + max_datagram_size: Option<u64>, initial_congestion_window: Option<u64>, + minimum_congestion_window: Option<u64>, + loss_reduction_factor: Option<u64>, + persistent_congestion_threshold: Option<u64>, + ) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType(RecoveryEventType::ParametersSet), + data: EventData::RecoveryParametersSet { + reordering_threshold, + time_threshold, + timer_granularity, + initial_rtt, + max_datagram_size, + initial_congestion_window, + minimum_congestion_window, + loss_reduction_factor, + persistent_congestion_threshold, + }, + } + } + + pub fn recovery_parameters_set_min() -> Self { + Event::recovery_parameters_set( + None, None, None, None, None, None, None, None, None, + ) + } + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::MetricsUpdated` + /// * `EventData`=`MetricsUpdated`. + pub fn metrics_updated( + min_rtt: Option<u64>, smoothed_rtt: Option<u64>, latest_rtt: Option<u64>, + rtt_variance: Option<u64>, max_ack_delay: Option<u64>, + pto_count: Option<u64>, congestion_window: Option<u64>, + bytes_in_flight: Option<u64>, ssthresh: Option<u64>, + packets_in_flight: Option<u64>, in_recovery: Option<bool>, + pacing_rate: Option<u64>, + ) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType(RecoveryEventType::MetricsUpdated), + data: EventData::MetricsUpdated { + min_rtt, + smoothed_rtt, + latest_rtt, + rtt_variance, + max_ack_delay, + pto_count, + congestion_window, + bytes_in_flight, + ssthresh, + packets_in_flight, + in_recovery, + pacing_rate, + }, + } + } + + pub fn metrics_updated_min() -> Self { + Event::metrics_updated( + None, None, None, None, None, None, None, None, None, None, None, + None, + ) + } + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::CongestionStateUpdated` + /// * `EventData`=`CongestionStateUpdated`. + pub fn congestion_state_updated(old: Option<String>, new: String) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType( + RecoveryEventType::CongestionStateUpdated, + ), + data: EventData::CongestionStateUpdated { old, new }, + } + } + + pub fn congestion_state_updated_min(new: String) -> Self { + Event::congestion_state_updated(None, new) + } + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::LossTimerSet` + /// * `EventData`=`LossTimerSet`. + pub fn loss_timer_set( + timer_type: Option<TimerType>, timeout: Option<String>, + ) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType(RecoveryEventType::LossTimerSet), + data: EventData::LossTimerSet { + timer_type, + timeout, + }, + } + } + + pub fn loss_timer_set_min() -> Self { + Event::loss_timer_set(None, None) + } + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::PacketLost` + /// * `EventData`=`PacketLost`. + pub fn packet_lost( + packet_type: PacketType, packet_number: String, + header: Option<PacketHeader>, frames: Vec<QuicFrame>, + ) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType(RecoveryEventType::PacketLost), + data: EventData::PacketLost { + packet_type, + packet_number, + header, + frames, + }, + } + } + + pub fn packet_lost_min( + packet_type: PacketType, packet_number: String, frames: Vec<QuicFrame>, + ) -> Self { + Event::packet_lost(packet_type, packet_number, None, frames) + } + + /// Returns: + /// * `EventCategory`=`Recovery` + /// * `EventType`=`RecoveryEventType::MarkedForRetransmit` + /// * `EventData`=`MarkedForRetransmit`. + pub fn marked_for_retransmit(frames: Vec<QuicFrame>) -> Self { + Event { + category: EventCategory::Recovery, + ty: EventType::RecoveryEventType( + RecoveryEventType::MarkedForRetransmit, + ), + data: EventData::MarkedForRetransmit { frames }, + } + } + + // HTTP/3 events. + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::ParametersSet` + /// * `EventData`=`H3ParametersSet`. + pub fn h3_parameters_set( + owner: Option<H3Owner>, max_header_list_size: Option<u64>, + max_table_capacity: Option<u64>, blocked_streams_count: Option<u64>, + push_allowed: Option<bool>, waits_for_settings: Option<bool>, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::ParametersSet), + data: EventData::H3ParametersSet { + owner, + max_header_list_size, + max_table_capacity, + blocked_streams_count, + push_allowed, + waits_for_settings, + }, + } + } + + pub fn h3_parameters_set_min() -> Self { + Event::h3_parameters_set(None, None, None, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::StreamTypeSet` + /// * `EventData`=`H3StreamTypeSet`. + pub fn h3_stream_type_set( + stream_id: String, owner: Option<H3Owner>, old: Option<H3StreamType>, + new: H3StreamType, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::StreamTypeSet), + data: EventData::H3StreamTypeSet { + stream_id, + owner, + old, + new, + }, + } + } + + pub fn h3_stream_type_set_min(stream_id: String, new: H3StreamType) -> Self { + Event::h3_stream_type_set(stream_id, None, None, new) + } + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::FrameCreated` + /// * `EventData`=`H3FrameCreated`. + pub fn h3_frame_created( + stream_id: String, frame: Http3Frame, byte_length: Option<String>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::FrameCreated), + data: EventData::H3FrameCreated { + stream_id, + frame, + byte_length, + raw, + }, + } + } + + pub fn h3_frame_created_min(stream_id: String, frame: Http3Frame) -> Self { + Event::h3_frame_created(stream_id, frame, None, None) + } + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::FrameParsed` + /// * `EventData`=`H3FrameParsed`. + pub fn h3_frame_parsed( + stream_id: String, frame: Http3Frame, byte_length: Option<String>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::FrameParsed), + data: EventData::H3FrameParsed { + stream_id, + frame, + byte_length, + raw, + }, + } + } + + pub fn h3_frame_parsed_min(stream_id: String, frame: Http3Frame) -> Self { + Event::h3_frame_parsed(stream_id, frame, None, None) + } + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::DataMoved` + /// * `EventData`=`H3DataMoved`. + pub fn h3_data_moved( + stream_id: String, offset: Option<String>, length: Option<u64>, + from: Option<H3DataRecipient>, to: Option<H3DataRecipient>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::DataMoved), + data: EventData::H3DataMoved { + stream_id, + offset, + length, + from, + to, + raw, + }, + } + } + + pub fn h3_data_moved_min(stream_id: String) -> Self { + Event::h3_data_moved(stream_id, None, None, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Http` + /// * `EventType`=`Http3EventType::PushResolved` + /// * `EventData`=`H3PushResolved`. + pub fn h3_push_resolved( + push_id: Option<String>, stream_id: Option<String>, + decision: Option<H3PushDecision>, + ) -> Self { + Event { + category: EventCategory::Http, + ty: EventType::Http3EventType(Http3EventType::PushResolved), + data: EventData::H3PushResolved { + push_id, + stream_id, + decision, + }, + } + } + + pub fn h3_push_resolved_min() -> Self { + Event::h3_push_resolved(None, None, None) + } + + // QPACK events. + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::StateUpdated` + /// * `EventData`=`QpackStateUpdated`. + pub fn qpack_state_updated( + owner: Option<QpackOwner>, dynamic_table_capacity: Option<u64>, + dynamic_table_size: Option<u64>, known_received_count: Option<u64>, + current_insert_count: Option<u64>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::StateUpdated), + data: EventData::QpackStateUpdated { + owner, + dynamic_table_capacity, + dynamic_table_size, + known_received_count, + current_insert_count, + }, + } + } + + pub fn qpack_state_updated_min() -> Self { + Event::qpack_state_updated(None, None, None, None, None) + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::StreamStateUpdated` + /// * `EventData`=`QpackStreamStateUpdated`. + pub fn qpack_stream_state_updated( + stream_id: String, state: QpackStreamState, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::StreamStateUpdated), + data: EventData::QpackStreamStateUpdated { stream_id, state }, + } + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::DynamicTableUpdated` + /// * `EventData`=`QpackDynamicTableUpdated`. + pub fn qpack_dynamic_table_updated( + update_type: QpackUpdateType, entries: Vec<QpackDynamicTableEntry>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::DynamicTableUpdated), + data: EventData::QpackDynamicTableUpdated { + update_type, + entries, + }, + } + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::HeadersEncoded` + /// * `EventData`=`QpackHeadersEncoded`. + pub fn qpack_headers_encoded( + stream_id: Option<String>, headers: Option<HttpHeader>, + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::HeadersEncoded), + data: EventData::QpackHeadersEncoded { + stream_id, + headers, + block_prefix, + header_block, + raw, + }, + } + } + + pub fn qpack_headers_encoded_min( + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, + ) -> Self { + Event::qpack_headers_encoded(None, None, block_prefix, header_block, None) + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::HeadersDecoded` + /// * `EventData`=`QpackHeadersDecoded`. + pub fn qpack_headers_decoded( + stream_id: Option<String>, headers: Option<HttpHeader>, + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::HeadersDecoded), + data: EventData::QpackHeadersDecoded { + stream_id, + headers, + block_prefix, + header_block, + raw, + }, + } + } + + pub fn qpack_headers_decoded_min( + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, + ) -> Self { + Event::qpack_headers_decoded(None, None, block_prefix, header_block, None) + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::InstructionSent` + /// * `EventData`=`QpackInstructionSent`. + pub fn qpack_instruction_sent( + instruction: QPackInstruction, byte_length: Option<String>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::InstructionSent), + data: EventData::QpackInstructionSent { + instruction, + byte_length, + raw, + }, + } + } + + pub fn qpack_instruction_sent_min(instruction: QPackInstruction) -> Self { + Event::qpack_instruction_sent(instruction, None, None) + } + + /// Returns: + /// * `EventCategory`=`Qpack` + /// * `EventType`=`QpackEventType::InstructionReceived` + /// * `EventData`=`QpackInstructionReceived`. + pub fn qpack_instruction_received( + instruction: QPackInstruction, byte_length: Option<String>, + raw: Option<String>, + ) -> Self { + Event { + category: EventCategory::Qpack, + ty: EventType::QpackEventType(QpackEventType::InstructionReceived), + data: EventData::QpackInstructionReceived { + instruction, + byte_length, + raw, + }, + } + } + + pub fn qpack_instruction_received_min(instruction: QPackInstruction) -> Self { + Event::qpack_instruction_received(instruction, None, None) + } + + /// Checks if the the combination of `EventCategory`, `EventType` and + /// `EventData` is valid. + pub fn is_valid(&self) -> bool { + match (&self.category, &self.ty) { + ( + EventCategory::Connectivity, + EventType::ConnectivityEventType(_), + ) => matches!(&self.data, + EventData::ServerListening { .. } | + EventData::ConnectionStarted { .. } | + EventData::ConnectionIdUpdated { .. } | + EventData::SpinBitUpdated { .. } | + EventData::ConnectionStateUpdated { .. }), + + (EventCategory::Transport, EventType::TransportEventType(_)) => + matches!(&self.data, + EventData::TransportParametersSet { .. } | + EventData::DatagramsReceived { .. } | + EventData::DatagramsSent { .. } | + EventData::DatagramDropped { .. } | + EventData::PacketReceived { .. } | + EventData::PacketSent { .. } | + EventData::PacketDropped { .. } | + EventData::PacketBuffered { .. } | + EventData::StreamStateUpdated { .. } | + EventData::FramesProcessed { .. }), + + (EventCategory::Security, EventType::SecurityEventType(_)) => + matches!(&self.data, + EventData::KeyUpdated { .. } | + EventData::KeyRetired { .. }), + + (EventCategory::Recovery, EventType::RecoveryEventType(_)) => + matches!(&self.data, + EventData::RecoveryParametersSet { .. } | + EventData::MetricsUpdated { .. } | + EventData::CongestionStateUpdated { .. } | + EventData::LossTimerSet { .. } | + EventData::PacketLost { .. } | + EventData::MarkedForRetransmit { .. }), + + (EventCategory::Http, EventType::Http3EventType(_)) => + matches!(&self.data, + EventData::H3ParametersSet { .. } | + EventData::H3StreamTypeSet { .. } | + EventData::H3FrameCreated { .. } | + EventData::H3FrameParsed { .. } | + EventData::H3DataMoved { .. } | + EventData::H3PushResolved { .. }), + + (EventCategory::Qpack, EventType::QpackEventType(_)) => + matches!(&self.data, + EventData::QpackStateUpdated { .. } | + EventData::QpackStreamStateUpdated { .. } | + EventData::QpackDynamicTableUpdated { .. } | + EventData::QpackHeadersEncoded { .. } | + EventData::QpackHeadersDecoded { .. } | + EventData::QpackInstructionSent { .. } | + EventData::QpackInstructionReceived { .. }), + + // TODO: in qlog-01 there is no sane default category defined for + // GenericEventType + (_, EventType::GenericEventType(_)) => matches!(&self.data, + EventData::ConnectionError { .. } | + EventData::ApplicationError { .. } | + EventData::InternalError { .. } | + EventData::InternalWarning { .. } | + EventData::Message { .. } | + EventData::Marker { .. }), + + _ => false, + } + } +} diff --git a/third_party/rust/qlog/src/lib.rs b/third_party/rust/qlog/src/lib.rs new file mode 100644 index 0000000000..d4a3bb45d0 --- /dev/null +++ b/third_party/rust/qlog/src/lib.rs @@ -0,0 +1,2970 @@ +// Copyright (C) 2019, Cloudflare, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +//! The qlog crate is an implementation of the [qlog main schema] and [qlog QUIC +//! and HTTP/3 events] that attempts to closely follow the format of the qlog +//! [TypeScript schema]. This is just a data model and no support is provided +//! for logging IO, applications can decide themselves the most appropriate +//! method. +//! +//! The crate uses Serde for conversion between Rust and JSON. +//! +//! [qlog main schema]: https://tools.ietf.org/html/draft-marx-qlog-main-schema +//! [qlog QUIC and HTTP/3 events]: +//! https://quiclog.github.io/internet-drafts/draft-marx-qlog-event-definitions-quic-h3 +//! [TypeScript schema]: +//! https://github.com/quiclog/qlog/blob/master/TypeScript/draft-01/QLog.ts +//! +//! Overview +//! --------------- +//! qlog is a hierarchical logging format, with a rough structure of: +//! +//! * Log +//! * Trace(s) +//! * Event(s) +//! +//! In practice, a single QUIC connection maps to a single Trace file with one +//! or more Events. Applications can decide whether to combine Traces from +//! different connections into the same Log. +//! +//! ## Traces +//! +//! A [`Trace`] contains metadata such as the [`VantagePoint`] of capture and +//! the [`Configuration`] of the `Trace`. +//! +//! A very important part of the `Trace` is the definition of `event_fields`. A +//! qlog Event is a vector of [`EventField`]; this provides great flexibility to +//! log events with any number of `EventFields` in any order. The `event_fields` +//! property describes the format of event logging and it is important that +//! events comply with that format. Failing to do so it going to cause problems +//! for qlog analysis tools. For information is available at +//! https://tools.ietf.org/html/draft-marx-qlog-main-schema-01#section-3.3.4 +//! +//! In order to make using qlog a bit easier, this crate expects a qlog Event to +//! consist of the following EventFields in the following order: +//! [`EventField::RelativeTime`], [`EventField::Category`], +//! [`EventField::Event`] and [`EventField::Data`]. A set of methods are +//! provided to assist in creating a Trace and appending events to it in this +//! format. +//! +//! ## Writing out logs +//! As events occur during the connection, the application appends them to the +//! trace. The qlog crate supports two modes of writing logs: the buffered mode +//! stores everything in memory and requires the application to serialize and +//! write the output, the streaming mode progressively writes serialized JSON +//! output to a writer designated by the application. +//! +//! ### Creating a Trace +//! +//! A typical application needs a single qlog [`Trace`] that it appends QUIC +//! and/or HTTP/3 events to: +//! +//! ``` +//! let mut trace = qlog::Trace::new( +//! qlog::VantagePoint { +//! name: Some("Example client".to_string()), +//! ty: qlog::VantagePointType::Client, +//! flow: None, +//! }, +//! Some("Example qlog trace".to_string()), +//! Some("Example qlog trace description".to_string()), +//! Some(qlog::Configuration { +//! time_offset: Some("0".to_string()), +//! time_units: Some(qlog::TimeUnits::Ms), +//! original_uris: None, +//! }), +//! None, +//! ); +//! ``` +//! +//! ## Adding events +//! +//! Qlog Events are added to [`qlog::Trace.events`]. +//! +//! It is recommended to use the provided utility methods to append semantically +//! valid events to a trace. However, there is nothing preventing you from +//! creating the events manually. +//! +//! The following example demonstrates how to log a QUIC packet +//! containing a single Crypto frame. It uses the [`QuicFrame::crypto()`], +//! [`packet_sent_min()`] and [`push_event()`] methods to create and log a +//! PacketSent event and its EventData. +//! +//! ``` +//! # let mut trace = qlog::Trace::new ( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None +//! # ); +//! +//! let scid = [0x7e, 0x37, 0xe4, 0xdc, 0xc6, 0x68, 0x2d, 0xa8]; +//! let dcid = [0x36, 0xce, 0x10, 0x4e, 0xee, 0x50, 0x10, 0x1c]; +//! +//! let pkt_hdr = qlog::PacketHeader::new( +//! 0, +//! Some(1251), +//! Some(1224), +//! Some(0xff00001b), +//! Some(b"7e37e4dcc6682da8"), +//! Some(&dcid), +//! ); +//! +//! let frames = +//! vec![qlog::QuicFrame::crypto("0".to_string(), "1000".to_string())]; +//! +//! let event = qlog::event::Event::packet_sent_min( +//! qlog::PacketType::Initial, +//! pkt_hdr, +//! Some(frames), +//! ); +//! +//! trace.push_event(std::time::Duration::new(0, 0), event); +//! ``` +//! +//! ### Serializing +//! +//! The qlog crate has only been tested with `serde_json`, however +//! other serializer targets might work. +//! +//! For example, serializing the trace created above: +//! +//! ``` +//! # let mut trace = qlog::Trace::new ( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None +//! # ); +//! serde_json::to_string_pretty(&trace).unwrap(); +//! ``` +//! +//! which would generate the following: +//! +//! ```ignore +//! { +//! "vantage_point": { +//! "name": "Example client", +//! "type": "client" +//! }, +//! "title": "Example qlog trace", +//! "description": "Example qlog trace description", +//! "configuration": { +//! "time_units": "ms", +//! "time_offset": "0" +//! }, +//! "event_fields": [ +//! "relative_time", +//! "category", +//! "event", +//! "data" +//! ], +//! "events": [ +//! [ +//! "0", +//! "transport", +//! "packet_sent", +//! { +//! "packet_type": "initial", +//! "header": { +//! "packet_number": "0", +//! "packet_size": 1251, +//! "payload_length": 1224, +//! "version": "ff00001b", +//! "scil": "8", +//! "dcil": "8", +//! "scid": "7e37e4dcc6682da8", +//! "dcid": "36ce104eee50101c" +//! }, +//! "frames": [ +//! { +//! "frame_type": "crypto", +//! "offset": "0", +//! "length": "100", +//! } +//! ] +//! } +//! ] +//! ] +//! } +//! ``` +//! +//! Streaming Mode +//! -------------- +//! +//! Create the trace: +//! +//! ``` +//! let mut trace = qlog::Trace::new( +//! qlog::VantagePoint { +//! name: Some("Example client".to_string()), +//! ty: qlog::VantagePointType::Client, +//! flow: None, +//! }, +//! Some("Example qlog trace".to_string()), +//! Some("Example qlog trace description".to_string()), +//! Some(qlog::Configuration { +//! time_offset: Some("0".to_string()), +//! time_units: Some(qlog::TimeUnits::Ms), +//! original_uris: None, +//! }), +//! None, +//! ); +//! ``` +//! Create an object with the [`Write`] trait: +//! +//! ``` +//! let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! ``` +//! +//! Create a [`QlogStreamer`] and start serialization to foo.qlog +//! using [`start_log()`]: +//! +//! ``` +//! # let mut trace = qlog::Trace::new( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None, +//! # ); +//! # let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! let mut streamer = qlog::QlogStreamer::new( +//! qlog::QLOG_VERSION.to_string(), +//! Some("Example qlog".to_string()), +//! Some("Example qlog description".to_string()), +//! None, +//! std::time::Instant::now(), +//! trace, +//! Box::new(file), +//! ); +//! +//! streamer.start_log().ok(); +//! ``` +//! +//! ### Adding simple events +//! +//! Once logging has started you can stream events. Simple events +//! can be written in one step using [`add_event()`]: +//! +//! ``` +//! # let mut trace = qlog::Trace::new( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None, +//! # ); +//! # let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! # let mut streamer = qlog::QlogStreamer::new( +//! # qlog::QLOG_VERSION.to_string(), +//! # Some("Example qlog".to_string()), +//! # Some("Example qlog description".to_string()), +//! # None, +//! # std::time::Instant::now(), +//! # trace, +//! # Box::new(file), +//! # ); +//! let event = qlog::event::Event::metrics_updated_min(); +//! streamer.add_event(event).ok(); +//! ``` +//! +//! ### Adding events with frames +//! Some events contain optional arrays of QUIC frames. If the +//! event has `Some(Vec<QuicFrame>)`, even if it is empty, the +//! streamer enters a frame serializing mode that must be +//! finalized before other events can be logged. +//! +//! In this example, a `PacketSent` event is created with an +//! empty frame array and frames are written out later: +//! +//! ``` +//! # let mut trace = qlog::Trace::new( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None, +//! # ); +//! # let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! # let mut streamer = qlog::QlogStreamer::new( +//! # qlog::QLOG_VERSION.to_string(), +//! # Some("Example qlog".to_string()), +//! # Some("Example qlog description".to_string()), +//! # None, +//! # std::time::Instant::now(), +//! # trace, +//! # Box::new(file), +//! # ); +//! let qlog_pkt_hdr = qlog::PacketHeader::with_type( +//! qlog::PacketType::OneRtt, +//! 0, +//! Some(1251), +//! Some(1224), +//! Some(0xff00001b), +//! Some(b"7e37e4dcc6682da8"), +//! Some(b"36ce104eee50101c"), +//! ); +//! +//! let event = qlog::event::Event::packet_sent_min( +//! qlog::PacketType::OneRtt, +//! qlog_pkt_hdr, +//! Some(Vec::new()), +//! ); +//! +//! streamer.add_event(event).ok(); +//! ``` +//! +//! In this example, the frames contained in the QUIC packet +//! are PING and PADDING. Each frame is written using the +//! [`add_frame()`] method. Frame writing is concluded with +//! [`finish_frames()`]. +//! +//! ``` +//! # let mut trace = qlog::Trace::new( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None, +//! # ); +//! # let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! # let mut streamer = qlog::QlogStreamer::new( +//! # qlog::QLOG_VERSION.to_string(), +//! # Some("Example qlog".to_string()), +//! # Some("Example qlog description".to_string()), +//! # None, +//! # std::time::Instant::now(), +//! # trace, +//! # Box::new(file), +//! # ); +//! +//! let ping = qlog::QuicFrame::ping(); +//! let padding = qlog::QuicFrame::padding(); +//! +//! streamer.add_frame(ping, false).ok(); +//! streamer.add_frame(padding, false).ok(); +//! +//! streamer.finish_frames().ok(); +//! ``` +//! +//! Once all events have have been written, the log +//! can be finalized with [`finish_log()`]: +//! +//! ``` +//! # let mut trace = qlog::Trace::new( +//! # qlog::VantagePoint { +//! # name: Some("Example client".to_string()), +//! # ty: qlog::VantagePointType::Client, +//! # flow: None, +//! # }, +//! # Some("Example qlog trace".to_string()), +//! # Some("Example qlog trace description".to_string()), +//! # Some(qlog::Configuration { +//! # time_offset: Some("0".to_string()), +//! # time_units: Some(qlog::TimeUnits::Ms), +//! # original_uris: None, +//! # }), +//! # None, +//! # ); +//! # let mut file = std::fs::File::create("foo.qlog").unwrap(); +//! # let mut streamer = qlog::QlogStreamer::new( +//! # qlog::QLOG_VERSION.to_string(), +//! # Some("Example qlog".to_string()), +//! # Some("Example qlog description".to_string()), +//! # None, +//! # std::time::Instant::now(), +//! # trace, +//! # Box::new(file), +//! # ); +//! streamer.finish_log().ok(); +//! ``` +//! +//! ### Serializing +//! +//! Serialization to JSON occurs as methods on the [`QlogStreamer`] +//! are called. No additional steps are required. +//! +//! [`Trace`]: struct.Trace.html +//! [`VantagePoint`]: struct.VantagePoint.html +//! [`Configuration`]: struct.Configuration.html +//! [`EventField`]: enum.EventField.html +//! [`EventField::RelativeTime`]: enum.EventField.html#variant.RelativeTime +//! [`EventField::Category`]: enum.EventField.html#variant.Category +//! [`EventField::Type`]: enum.EventField.html#variant.Type +//! [`EventField::Data`]: enum.EventField.html#variant.Data +//! [`qlog::Trace.events`]: struct.Trace.html#structfield.events +//! [`push_event()`]: struct.Trace.html#method.push_event +//! [`packet_sent_min()`]: event/struct.Event.html#method.packet_sent_min +//! [`QuicFrame::crypto()`]: enum.QuicFrame.html#variant.Crypto +//! [`QlogStreamer`]: struct.QlogStreamer.html +//! [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html +//! [`start_log()`]: struct.QlogStreamer.html#method.start_log +//! [`add_event()`]: struct.QlogStreamer.html#method.add_event +//! [`add_frame()`]: struct.QlogStreamer.html#method.add_frame +//! [`finish_frames()`]: struct.QlogStreamer.html#method.finish_frames +//! [`finish_log()`]: struct.QlogStreamer.html#method.finish_log + +use serde::Serialize; + +/// A quiche qlog error. +#[derive(Debug)] +pub enum Error { + /// There is no more work to do. + Done, + + /// The operation cannot be completed because it was attempted + /// in an invalid state. + InvalidState, + + /// I/O error. + IoError(std::io::Error), +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + write!(f, "{:?}", self) + } +} + +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + None + } +} + +impl std::convert::From<std::io::Error> for Error { + fn from(err: std::io::Error) -> Self { + Error::IoError(err) + } +} + +pub const QLOG_VERSION: &str = "draft-02-wip"; + +/// A specialized [`Result`] type for quiche qlog operations. +/// +/// This type is used throughout the public API for any operation that +/// can produce an error. +/// +/// [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html +pub type Result<T> = std::result::Result<T, Error>; + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +pub struct Qlog { + pub qlog_version: String, + pub title: Option<String>, + pub description: Option<String>, + pub summary: Option<String>, + + pub traces: Vec<Trace>, +} + +impl Default for Qlog { + fn default() -> Self { + Qlog { + qlog_version: QLOG_VERSION.to_string(), + title: Some("Default qlog title".to_string()), + description: Some("Default qlog description".to_string()), + summary: Some("Default qlog title".to_string()), + traces: Vec::new(), + } + } +} + +#[derive(PartialEq)] +pub enum StreamerState { + Initial, + Ready, + WritingFrames, + Finished, +} + +/// A helper object specialized for streaming JSON-serialized qlog to a +/// [`Write`] trait. +/// +/// The object is responsible for the `Qlog` object that contains the provided +/// `Trace`. +/// +/// Serialization is progressively driven by method calls; once log streaming is +/// started, `event::Events` can be written using `add_event()`. Some events +/// can contain an array of `QuicFrame`s, when writing such an event, the +/// streamer enters a frame-serialization mode where frames are be progressively +/// written using `add_frame()`. This mode is concluded using +/// `finished_frames()`. While serializing frames, any attempts to log +/// additional events are ignored. +/// +/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html +pub struct QlogStreamer { + start_time: std::time::Instant, + writer: Box<dyn std::io::Write + Send + Sync>, + qlog: Qlog, + state: StreamerState, + first_event: bool, + first_frame: bool, +} + +impl QlogStreamer { + /// Creates a QlogStreamer object. + /// + /// It owns a `Qlog` object that contains the provided `Trace`, which must + /// have the following ordered-set of names EventFields: + /// + /// ["relative_time", "category", "event".to_string(), "data"] + /// + /// All serialization will be written to the provided `Write`. + pub fn new( + qlog_version: String, title: Option<String>, description: Option<String>, + summary: Option<String>, start_time: std::time::Instant, trace: Trace, + writer: Box<dyn std::io::Write + Send + Sync>, + ) -> Self { + let qlog = Qlog { + qlog_version, + title, + description, + summary, + traces: vec![trace], + }; + + QlogStreamer { + start_time, + writer, + qlog, + state: StreamerState::Initial, + first_event: true, + first_frame: false, + } + } + + /// Starts qlog streaming serialization. + /// + /// This writes out the JSON-serialized form of all information up to qlog + /// `Trace`'s array of `EventField`s. EventFields are separately appended + /// using functions that accept and `event::Event`. + pub fn start_log(&mut self) -> Result<()> { + if self.state != StreamerState::Initial { + return Err(Error::Done); + } + + // A qlog contains a trace holding a vector of events that we want to + // serialize in a streaming manner. So at the start of serialization, + // take off all closing delimiters, and leave us in a state to accept + // new events. + match serde_json::to_string(&self.qlog) { + Ok(mut out) => { + out.truncate(out.len() - 4); + + self.writer.as_mut().write_all(out.as_bytes())?; + + self.state = StreamerState::Ready; + + self.first_event = self.qlog.traces[0].events.is_empty(); + }, + + _ => return Err(Error::Done), + } + + Ok(()) + } + + /// Finishes qlog streaming serialization. + /// + /// The JSON-serialized output has remaining close delimiters added. + /// After this is called, no more serialization will occur. + pub fn finish_log(&mut self) -> Result<()> { + if self.state == StreamerState::Initial || + self.state == StreamerState::Finished + { + return Err(Error::InvalidState); + } + + self.writer.as_mut().write_all(b"]}]}")?; + + self.state = StreamerState::Finished; + + self.writer.as_mut().flush()?; + + Ok(()) + } + + /// Writes a JSON-serialized `EventField`s. + /// + /// Some qlog events can contain `QuicFrames`. If this is detected `true` is + /// returned and the streamer enters a frame-serialization mode that is only + /// concluded by `finish_frames()`. In this mode, attempts to log additional + /// events are ignored. + /// + /// If the event contains no array of `QuicFrames` return `false`. + pub fn add_event(&mut self, event: event::Event) -> Result<bool> { + if self.state != StreamerState::Ready { + return Err(Error::InvalidState); + } + + let event_time = if cfg!(test) { + std::time::Duration::from_secs(0) + } else { + self.start_time.elapsed() + }; + + let rel = match &self.qlog.traces[0].configuration { + Some(conf) => match conf.time_units { + Some(TimeUnits::Ms) => event_time.as_millis().to_string(), + + Some(TimeUnits::Us) => event_time.as_micros().to_string(), + + None => String::from(""), + }, + + None => String::from(""), + }; + + let (ev_data, contains_frames) = match serde_json::to_string(&event.data) + { + Ok(mut ev_data_out) => + if let Some(f) = event.data.contains_quic_frames() { + ev_data_out.truncate(ev_data_out.len() - 2); + + if f == 0 { + self.first_frame = true; + } + + (ev_data_out, true) + } else { + (ev_data_out, false) + }, + + _ => return Err(Error::Done), + }; + + let maybe_comma = if self.first_event { + self.first_event = false; + "" + } else { + "," + }; + + let maybe_terminate = if contains_frames { "" } else { "]" }; + + let ev_time = serde_json::to_string(&EventField::RelativeTime(rel)).ok(); + let ev_cat = + serde_json::to_string(&EventField::Category(event.category)).ok(); + let ev_ty = serde_json::to_string(&EventField::Event(event.ty)).ok(); + + if let (Some(ev_time), Some(ev_cat), Some(ev_ty)) = + (ev_time, ev_cat, ev_ty) + { + let out = format!( + "{}[{},{},{},{}{}", + maybe_comma, ev_time, ev_cat, ev_ty, ev_data, maybe_terminate + ); + + self.writer.as_mut().write_all(out.as_bytes())?; + + if contains_frames { + self.state = StreamerState::WritingFrames + } else { + self.state = StreamerState::Ready + }; + + return Ok(contains_frames); + } + + Err(Error::Done) + } + + /// Writes a JSON-serialized `QuicFrame`. + /// + /// Only valid while in the frame-serialization mode. + pub fn add_frame(&mut self, frame: QuicFrame, last: bool) -> Result<()> { + if self.state != StreamerState::WritingFrames { + return Err(Error::InvalidState); + } + + match serde_json::to_string(&frame) { + Ok(mut out) => { + if !self.first_frame { + out.insert(0, ','); + } else { + self.first_frame = false; + } + + self.writer.as_mut().write_all(out.as_bytes())?; + + if last { + self.finish_frames()?; + } + }, + + _ => return Err(Error::Done), + } + + Ok(()) + } + + /// Concludes `QuicFrame` streaming serialization. + /// + /// Only valid while in the frame-serialization mode. + pub fn finish_frames(&mut self) -> Result<()> { + if self.state != StreamerState::WritingFrames { + return Err(Error::InvalidState); + } + + self.writer.as_mut().write_all(b"]}]")?; + self.state = StreamerState::Ready; + + Ok(()) + } + + /// Returns the writer. + #[allow(clippy::borrowed_box)] + pub fn writer(&self) -> &Box<dyn std::io::Write + Send + Sync> { + &self.writer + } +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +pub struct Trace { + pub vantage_point: VantagePoint, + pub title: Option<String>, + pub description: Option<String>, + + pub configuration: Option<Configuration>, + + pub common_fields: Option<CommonFields>, + pub event_fields: Vec<String>, + + pub events: Vec<Vec<EventField>>, +} + +/// Helper functions for using a qlog trace. +impl Trace { + /// Creates a new qlog trace with the hard-coded event_fields + /// ["relative_time", "category", "event", "data"] + pub fn new( + vantage_point: VantagePoint, title: Option<String>, + description: Option<String>, configuration: Option<Configuration>, + common_fields: Option<CommonFields>, + ) -> Self { + Trace { + vantage_point, + title, + description, + configuration, + common_fields, + event_fields: vec![ + "relative_time".to_string(), + "category".to_string(), + "event".to_string(), + "data".to_string(), + ], + events: Vec::new(), + } + } + + pub fn push_event( + &mut self, relative_time: std::time::Duration, event: crate::event::Event, + ) { + let rel = match &self.configuration { + Some(conf) => match conf.time_units { + Some(TimeUnits::Ms) => relative_time.as_millis().to_string(), + + Some(TimeUnits::Us) => relative_time.as_micros().to_string(), + + None => String::from(""), + }, + + None => String::from(""), + }; + + self.events.push(vec![ + EventField::RelativeTime(rel), + EventField::Category(event.category), + EventField::Event(event.ty), + EventField::Data(event.data), + ]); + } +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +pub struct VantagePoint { + pub name: Option<String>, + + #[serde(rename = "type")] + pub ty: VantagePointType, + + pub flow: Option<VantagePointType>, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum VantagePointType { + Client, + Server, + Network, + Unknown, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TimeUnits { + Ms, + Us, +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +pub struct Configuration { + pub time_units: Option<TimeUnits>, + pub time_offset: Option<String>, + + pub original_uris: Option<Vec<String>>, + /* TODO + * additionalUserSpecifiedProperty */ +} + +impl Default for Configuration { + fn default() -> Self { + Configuration { + time_units: Some(TimeUnits::Ms), + time_offset: Some("0".to_string()), + original_uris: None, + } + } +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone, Default)] +pub struct CommonFields { + pub group_id: Option<String>, + pub protocol_type: Option<String>, + + pub reference_time: Option<String>, + /* TODO + * additionalUserSpecifiedProperty */ +} + +#[derive(Serialize, Clone)] +#[serde(untagged)] +pub enum EventType { + ConnectivityEventType(ConnectivityEventType), + + TransportEventType(TransportEventType), + + SecurityEventType(SecurityEventType), + + RecoveryEventType(RecoveryEventType), + + Http3EventType(Http3EventType), + + QpackEventType(QpackEventType), + + GenericEventType(GenericEventType), +} + +#[derive(Serialize, Clone)] +#[serde(untagged)] +#[allow(clippy::large_enum_variant)] +pub enum EventField { + RelativeTime(String), + + Category(EventCategory), + + Event(EventType), + + Data(EventData), +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum EventCategory { + Connectivity, + Security, + Transport, + Recovery, + Http, + Qpack, + + Error, + Warning, + Info, + Debug, + Verbose, + Simulation, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum ConnectivityEventType { + ServerListening, + ConnectionStarted, + ConnectionIdUpdated, + SpinBitUpdated, + ConnectionStateUpdated, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TransportEventType { + ParametersSet, + + DatagramsSent, + DatagramsReceived, + DatagramDropped, + + PacketSent, + PacketReceived, + PacketDropped, + PacketBuffered, + + FramesProcessed, + + StreamStateUpdated, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TransportEventTrigger { + Line, + Retransmit, + KeysUnavailable, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum SecurityEventType { + KeyUpdated, + KeyRetired, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum SecurityEventTrigger { + Tls, + Implicit, + RemoteUpdate, + LocalUpdate, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum RecoveryEventType { + ParametersSet, + MetricsUpdated, + CongestionStateUpdated, + LossTimerSet, + LossTimerTriggered, + PacketLost, + MarkedForRetransmit, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum RecoveryEventTrigger { + AckReceived, + PacketSent, + Alarm, + Unknown, +} + +// ================================================================== // + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum KeyType { + ServerInitialSecret, + ClientInitialSecret, + + ServerHandshakeSecret, + ClientHandshakeSecret, + + Server0RttSecret, + Client0RttSecret, + + Server1RttSecret, + Client1RttSecret, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum ConnectionState { + Attempted, + Reset, + Handshake, + Active, + Keepalive, + Draining, + Closed, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TransportOwner { + Local, + Remote, +} + +#[derive(Serialize, Clone)] +pub struct PreferredAddress { + pub ip_v4: String, + pub ip_v6: String, + + pub port_v4: u64, + pub port_v6: u64, + + pub connection_id: String, + pub stateless_reset_token: String, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum StreamSide { + Sending, + Receiving, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum StreamState { + // bidirectional stream states, draft-23 3.4. + Idle, + Open, + HalfClosedLocal, + HalfClosedRemote, + Closed, + + // sending-side stream states, draft-23 3.1. + Ready, + Send, + DataSent, + ResetSent, + ResetReceived, + + // receive-side stream states, draft-23 3.2. + Receive, + SizeKnown, + DataRead, + ResetRead, + + // both-side states + DataReceived, + + // qlog-defined + Destroyed, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TimerType { + Ack, + Pto, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum H3Owner { + Local, + Remote, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum H3StreamType { + Data, + Control, + Push, + Reserved, + QpackEncode, + QpackDecode, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum H3DataRecipient { + Application, + Transport, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum H3PushDecision { + Claimed, + Abandoned, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackOwner { + Local, + Remote, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackStreamState { + Blocked, + Unblocked, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackUpdateType { + Added, + Evicted, +} + +#[derive(Serialize, Clone)] +pub struct QpackDynamicTableEntry { + pub index: u64, + pub name: Option<String>, + pub value: Option<String>, +} + +#[derive(Serialize, Clone)] +pub struct QpackHeaderBlockPrefix { + pub required_insert_count: u64, + pub sign_bit: bool, + pub delta_base: u64, +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +#[serde(untagged)] +#[allow(clippy::large_enum_variant)] +pub enum EventData { + // ================================================================== // + // CONNECTIVITY + ServerListening { + ip_v4: Option<String>, + ip_v6: Option<String>, + port_v4: u64, + port_v6: u64, + + quic_versions: Option<Vec<String>>, + alpn_values: Option<Vec<String>>, + + stateless_reset_required: Option<bool>, + }, + + ConnectionStarted { + ip_version: String, + src_ip: String, + dst_ip: String, + + protocol: Option<String>, + src_port: u64, + dst_port: u64, + + quic_version: Option<String>, + src_cid: Option<String>, + dst_cid: Option<String>, + }, + + ConnectionIdUpdated { + src_old: Option<String>, + src_new: Option<String>, + + dst_old: Option<String>, + dst_new: Option<String>, + }, + + SpinBitUpdated { + state: bool, + }, + + ConnectionStateUpdated { + old: Option<ConnectionState>, + new: ConnectionState, + }, + + // ================================================================== // + // SECURITY + KeyUpdated { + key_type: KeyType, + old: Option<String>, + new: String, + generation: Option<u64>, + }, + + KeyRetired { + key_type: KeyType, + key: Option<String>, + generation: Option<u64>, + }, + + // ================================================================== // + // TRANSPORT + TransportParametersSet { + owner: Option<TransportOwner>, + + resumption_allowed: Option<bool>, + early_data_enabled: Option<bool>, + alpn: Option<String>, + version: Option<String>, + tls_cipher: Option<String>, + + original_connection_id: Option<String>, + stateless_reset_token: Option<String>, + disable_active_migration: Option<bool>, + + idle_timeout: Option<u64>, + max_packet_size: Option<u64>, + ack_delay_exponent: Option<u64>, + max_ack_delay: Option<u64>, + active_connection_id_limit: Option<u64>, + + initial_max_data: Option<String>, + initial_max_stream_data_bidi_local: Option<String>, + initial_max_stream_data_bidi_remote: Option<String>, + initial_max_stream_data_uni: Option<String>, + initial_max_streams_bidi: Option<String>, + initial_max_streams_uni: Option<String>, + + preferred_address: Option<PreferredAddress>, + }, + + DatagramsReceived { + count: Option<u64>, + byte_length: Option<u64>, + }, + + DatagramsSent { + count: Option<u64>, + byte_length: Option<u64>, + }, + + DatagramDropped { + byte_length: Option<u64>, + }, + + PacketReceived { + packet_type: PacketType, + header: PacketHeader, + // `frames` is defined here in the QLog schema specification. However, + // our streaming serializer requires serde to put the object at the end, + // so we define it there and depend on serde's preserve_order feature. + is_coalesced: Option<bool>, + + raw_encrypted: Option<String>, + raw_decrypted: Option<String>, + frames: Option<Vec<QuicFrame>>, + }, + + PacketSent { + packet_type: PacketType, + header: PacketHeader, + // `frames` is defined here in the QLog schema specification. However, + // our streaming serializer requires serde to put the object at the end, + // so we define it there and depend on serde's preserve_order feature. + is_coalesced: Option<bool>, + + raw_encrypted: Option<String>, + raw_decrypted: Option<String>, + frames: Option<Vec<QuicFrame>>, + }, + + PacketDropped { + packet_type: Option<PacketType>, + packet_size: Option<u64>, + + raw: Option<String>, + }, + + PacketBuffered { + packet_type: PacketType, + packet_number: String, + }, + + StreamStateUpdated { + stream_id: String, + stream_type: Option<StreamType>, + + old: Option<StreamState>, + new: StreamState, + + stream_side: Option<StreamSide>, + }, + + FramesProcessed { + frames: Vec<QuicFrame>, + }, + + // ================================================================== // + // RECOVERY + RecoveryParametersSet { + reordering_threshold: Option<u64>, + time_threshold: Option<u64>, + timer_granularity: Option<u64>, + initial_rtt: Option<u64>, + + max_datagram_size: Option<u64>, + initial_congestion_window: Option<u64>, + minimum_congestion_window: Option<u64>, + loss_reduction_factor: Option<u64>, + persistent_congestion_threshold: Option<u64>, + }, + + MetricsUpdated { + min_rtt: Option<u64>, + smoothed_rtt: Option<u64>, + latest_rtt: Option<u64>, + rtt_variance: Option<u64>, + + max_ack_delay: Option<u64>, + pto_count: Option<u64>, + + congestion_window: Option<u64>, + bytes_in_flight: Option<u64>, + + ssthresh: Option<u64>, + + // qlog defined + packets_in_flight: Option<u64>, + in_recovery: Option<bool>, + + pacing_rate: Option<u64>, + }, + + CongestionStateUpdated { + old: Option<String>, + new: String, + }, + + LossTimerSet { + timer_type: Option<TimerType>, + timeout: Option<String>, + }, + + PacketLost { + packet_type: PacketType, + packet_number: String, + + header: Option<PacketHeader>, + frames: Vec<QuicFrame>, + }, + + MarkedForRetransmit { + frames: Vec<QuicFrame>, + }, + + // ================================================================== // + // HTTP/3 + H3ParametersSet { + owner: Option<H3Owner>, + + max_header_list_size: Option<u64>, + max_table_capacity: Option<u64>, + blocked_streams_count: Option<u64>, + + push_allowed: Option<bool>, + + waits_for_settings: Option<bool>, + }, + + H3StreamTypeSet { + stream_id: String, + owner: Option<H3Owner>, + + old: Option<H3StreamType>, + new: H3StreamType, + }, + + H3FrameCreated { + stream_id: String, + frame: Http3Frame, + byte_length: Option<String>, + + raw: Option<String>, + }, + + H3FrameParsed { + stream_id: String, + frame: Http3Frame, + byte_length: Option<String>, + + raw: Option<String>, + }, + + H3DataMoved { + stream_id: String, + offset: Option<String>, + length: Option<u64>, + + from: Option<H3DataRecipient>, + to: Option<H3DataRecipient>, + + raw: Option<String>, + }, + + H3PushResolved { + push_id: Option<String>, + stream_id: Option<String>, + + decision: Option<H3PushDecision>, + }, + + // ================================================================== // + // QPACK + QpackStateUpdated { + owner: Option<QpackOwner>, + + dynamic_table_capacity: Option<u64>, + dynamic_table_size: Option<u64>, + + known_received_count: Option<u64>, + current_insert_count: Option<u64>, + }, + + QpackStreamStateUpdated { + stream_id: String, + + state: QpackStreamState, + }, + + QpackDynamicTableUpdated { + update_type: QpackUpdateType, + + entries: Vec<QpackDynamicTableEntry>, + }, + + QpackHeadersEncoded { + stream_id: Option<String>, + + headers: Option<HttpHeader>, + + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, + + raw: Option<String>, + }, + + QpackHeadersDecoded { + stream_id: Option<String>, + + headers: Option<HttpHeader>, + + block_prefix: QpackHeaderBlockPrefix, + header_block: Vec<QpackHeaderBlockRepresentation>, + + raw: Option<String>, + }, + + QpackInstructionSent { + instruction: QPackInstruction, + byte_length: Option<String>, + + raw: Option<String>, + }, + + QpackInstructionReceived { + instruction: QPackInstruction, + byte_length: Option<String>, + + raw: Option<String>, + }, + + // ================================================================== // + // Generic + ConnectionError { + code: Option<ConnectionErrorCode>, + description: Option<String>, + }, + + ApplicationError { + code: Option<ApplicationErrorCode>, + description: Option<String>, + }, + + InternalError { + code: Option<u64>, + description: Option<String>, + }, + + InternalWarning { + code: Option<u64>, + description: Option<String>, + }, + + Message { + message: String, + }, + + Marker { + marker_type: String, + message: Option<String>, + }, +} + +impl EventData { + /// Returns size of `EventData` array of `QuicFrame`s if it exists. + pub fn contains_quic_frames(&self) -> Option<usize> { + // For some EventData variants, the frame array is optional + // but for others it is mandatory. + match self { + EventData::PacketSent { frames, .. } | + EventData::PacketReceived { frames, .. } => + if let Some(f) = frames { + Some(f.len()) + } else { + None + }, + + EventData::PacketLost { frames, .. } | + EventData::MarkedForRetransmit { frames } | + EventData::FramesProcessed { frames } => Some(frames.len()), + + _ => None, + } + } +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum PacketType { + Initial, + Handshake, + + #[serde(rename = "0RTT")] + ZeroRtt, + + #[serde(rename = "1RTT")] + OneRtt, + + Retry, + VersionNegotiation, + Unknown, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum Http3EventType { + ParametersSet, + StreamTypeSet, + FrameCreated, + FrameParsed, + DataMoved, + PushResolved, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackEventType { + StateUpdated, + StreamStateUpdated, + DynamicTableUpdated, + HeadersEncoded, + HeadersDecoded, + InstructionSent, + InstructionReceived, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QuicFrameTypeName { + Padding, + Ping, + Ack, + ResetStream, + StopSending, + Crypto, + NewToken, + Stream, + MaxData, + MaxStreamData, + MaxStreams, + DataBlocked, + StreamDataBlocked, + StreamsBlocked, + NewConnectionId, + RetireConnectionId, + PathChallenge, + PathResponse, + ConnectionClose, + ApplicationClose, + HandshakeDone, + Datagram, + Unknown, +} + +// TODO: search for pub enum Error { to see how best to encode errors in qlog. +#[serde_with::skip_serializing_none] +#[derive(Clone, Serialize)] +pub struct PacketHeader { + pub packet_number: String, + pub packet_size: Option<u64>, + pub payload_length: Option<u64>, + pub version: Option<String>, + pub scil: Option<String>, + pub dcil: Option<String>, + pub scid: Option<String>, + pub dcid: Option<String>, +} + +impl PacketHeader { + /// Creates a new PacketHeader. + pub fn new( + packet_number: u64, packet_size: Option<u64>, + payload_length: Option<u64>, version: Option<u32>, scid: Option<&[u8]>, + dcid: Option<&[u8]>, + ) -> Self { + let (scil, scid) = match scid { + Some(cid) => ( + Some(cid.len().to_string()), + Some(format!("{}", HexSlice::new(&cid))), + ), + + None => (None, None), + }; + + let (dcil, dcid) = match dcid { + Some(cid) => ( + Some(cid.len().to_string()), + Some(format!("{}", HexSlice::new(&cid))), + ), + + None => (None, None), + }; + + let version = match version { + Some(v) => Some(format!("{:x?}", v)), + + None => None, + }; + + PacketHeader { + packet_number: packet_number.to_string(), + packet_size, + payload_length, + version, + scil, + dcil, + scid, + dcid, + } + } + + /// Creates a new PacketHeader. + /// + /// Once a QUIC connection has formed, version, dcid and scid are stable, so + /// there are space benefits to not logging them in every packet, especially + /// PacketType::OneRtt. + pub fn with_type( + ty: PacketType, packet_number: u64, packet_size: Option<u64>, + payload_length: Option<u64>, version: Option<u32>, scid: Option<&[u8]>, + dcid: Option<&[u8]>, + ) -> Self { + match ty { + PacketType::OneRtt => PacketHeader::new( + packet_number, + packet_size, + payload_length, + None, + None, + None, + ), + + _ => PacketHeader::new( + packet_number, + packet_size, + payload_length, + version, + scid, + dcid, + ), + } + } +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum StreamType { + Bidirectional, + Unidirectional, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum ErrorSpace { + TransportError, + ApplicationError, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum GenericEventType { + ConnectionError, + ApplicationError, + InternalError, + InternalWarning, + + Message, + Marker, +} + +#[derive(Serialize, Clone)] +#[serde(untagged)] +pub enum ConnectionErrorCode { + TransportError(TransportError), + CryptoError(CryptoError), + Value(u64), +} + +#[derive(Serialize, Clone)] +#[serde(untagged)] +pub enum ApplicationErrorCode { + ApplicationError(ApplicationError), + Value(u64), +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum TransportError { + NoError, + InternalError, + ServerBusy, + FlowControlError, + StreamLimitError, + StreamStateError, + FinalSizeError, + FrameEncodingError, + TransportParameterError, + ProtocolViolation, + InvalidMigration, + CryptoBufferExceeded, + Unknown, +} + +// TODO +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum CryptoError { + Prefix, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum ApplicationError { + HttpNoError, + HttpGeneralProtocolError, + HttpInternalError, + HttpRequestCancelled, + HttpIncompleteRequest, + HttpConnectError, + HttpFrameError, + HttpExcessiveLoad, + HttpVersionFallback, + HttpIdError, + HttpStreamCreationError, + HttpClosedCriticalStream, + HttpEarlyResponse, + HttpMissingSettings, + HttpUnexpectedFrame, + HttpRequestRejection, + HttpSettingsError, + Unknown, +} + +#[serde_with::skip_serializing_none] +#[derive(Serialize, Clone)] +#[serde(untagged)] +pub enum QuicFrame { + Padding { + frame_type: QuicFrameTypeName, + }, + + Ping { + frame_type: QuicFrameTypeName, + }, + + Ack { + frame_type: QuicFrameTypeName, + ack_delay: Option<String>, + acked_ranges: Option<Vec<(u64, u64)>>, + + ect1: Option<String>, + + ect0: Option<String>, + + ce: Option<String>, + }, + + ResetStream { + frame_type: QuicFrameTypeName, + stream_id: String, + error_code: u64, + final_size: String, + }, + + StopSending { + frame_type: QuicFrameTypeName, + stream_id: String, + error_code: u64, + }, + + Crypto { + frame_type: QuicFrameTypeName, + offset: String, + length: String, + }, + + NewToken { + frame_type: QuicFrameTypeName, + length: String, + token: String, + }, + + Stream { + frame_type: QuicFrameTypeName, + stream_id: String, + offset: String, + length: String, + fin: bool, + + raw: Option<String>, + }, + + MaxData { + frame_type: QuicFrameTypeName, + maximum: String, + }, + + MaxStreamData { + frame_type: QuicFrameTypeName, + stream_id: String, + maximum: String, + }, + + MaxStreams { + frame_type: QuicFrameTypeName, + stream_type: StreamType, + maximum: String, + }, + + DataBlocked { + frame_type: QuicFrameTypeName, + limit: String, + }, + + StreamDataBlocked { + frame_type: QuicFrameTypeName, + stream_id: String, + limit: String, + }, + + StreamsBlocked { + frame_type: QuicFrameTypeName, + stream_type: StreamType, + limit: String, + }, + + NewConnectionId { + frame_type: QuicFrameTypeName, + sequence_number: String, + retire_prior_to: String, + length: u64, + connection_id: String, + reset_token: String, + }, + + RetireConnectionId { + frame_type: QuicFrameTypeName, + sequence_number: String, + }, + + PathChallenge { + frame_type: QuicFrameTypeName, + + data: Option<String>, + }, + + PathResponse { + frame_type: QuicFrameTypeName, + + data: Option<String>, + }, + + ConnectionClose { + frame_type: QuicFrameTypeName, + error_space: ErrorSpace, + error_code: u64, + raw_error_code: u64, + reason: String, + + trigger_frame_type: Option<String>, + }, + + HandshakeDone { + frame_type: QuicFrameTypeName, + }, + + Datagram { + frame_type: QuicFrameTypeName, + length: String, + + raw: Option<String>, + }, + + Unknown { + frame_type: QuicFrameTypeName, + raw_frame_type: u64, + }, +} + +impl QuicFrame { + pub fn padding() -> Self { + QuicFrame::Padding { + frame_type: QuicFrameTypeName::Padding, + } + } + + pub fn ping() -> Self { + QuicFrame::Ping { + frame_type: QuicFrameTypeName::Ping, + } + } + + pub fn ack( + ack_delay: Option<String>, acked_ranges: Option<Vec<(u64, u64)>>, + ect1: Option<String>, ect0: Option<String>, ce: Option<String>, + ) -> Self { + QuicFrame::Ack { + frame_type: QuicFrameTypeName::Ack, + ack_delay, + acked_ranges, + ect1, + ect0, + ce, + } + } + + pub fn reset_stream( + stream_id: String, error_code: u64, final_size: String, + ) -> Self { + QuicFrame::ResetStream { + frame_type: QuicFrameTypeName::ResetStream, + stream_id, + error_code, + final_size, + } + } + + pub fn stop_sending(stream_id: String, error_code: u64) -> Self { + QuicFrame::StopSending { + frame_type: QuicFrameTypeName::StopSending, + stream_id, + error_code, + } + } + + pub fn crypto(offset: String, length: String) -> Self { + QuicFrame::Crypto { + frame_type: QuicFrameTypeName::Crypto, + offset, + length, + } + } + + pub fn new_token(length: String, token: String) -> Self { + QuicFrame::NewToken { + frame_type: QuicFrameTypeName::NewToken, + length, + token, + } + } + + pub fn stream( + stream_id: String, offset: String, length: String, fin: bool, + raw: Option<String>, + ) -> Self { + QuicFrame::Stream { + frame_type: QuicFrameTypeName::Stream, + stream_id, + offset, + length, + fin, + raw, + } + } + + pub fn max_data(maximum: String) -> Self { + QuicFrame::MaxData { + frame_type: QuicFrameTypeName::MaxData, + maximum, + } + } + + pub fn max_stream_data(stream_id: String, maximum: String) -> Self { + QuicFrame::MaxStreamData { + frame_type: QuicFrameTypeName::MaxStreamData, + stream_id, + maximum, + } + } + + pub fn max_streams(stream_type: StreamType, maximum: String) -> Self { + QuicFrame::MaxStreams { + frame_type: QuicFrameTypeName::MaxStreams, + stream_type, + maximum, + } + } + + pub fn data_blocked(limit: String) -> Self { + QuicFrame::DataBlocked { + frame_type: QuicFrameTypeName::DataBlocked, + limit, + } + } + + pub fn stream_data_blocked(stream_id: String, limit: String) -> Self { + QuicFrame::StreamDataBlocked { + frame_type: QuicFrameTypeName::StreamDataBlocked, + stream_id, + limit, + } + } + + pub fn streams_blocked(stream_type: StreamType, limit: String) -> Self { + QuicFrame::StreamsBlocked { + frame_type: QuicFrameTypeName::StreamsBlocked, + stream_type, + limit, + } + } + + pub fn new_connection_id( + sequence_number: String, retire_prior_to: String, length: u64, + connection_id: String, reset_token: String, + ) -> Self { + QuicFrame::NewConnectionId { + frame_type: QuicFrameTypeName::NewConnectionId, + sequence_number, + retire_prior_to, + length, + connection_id, + reset_token, + } + } + + pub fn retire_connection_id(sequence_number: String) -> Self { + QuicFrame::RetireConnectionId { + frame_type: QuicFrameTypeName::RetireConnectionId, + sequence_number, + } + } + + pub fn path_challenge(data: Option<String>) -> Self { + QuicFrame::PathChallenge { + frame_type: QuicFrameTypeName::PathChallenge, + data, + } + } + + pub fn path_response(data: Option<String>) -> Self { + QuicFrame::PathResponse { + frame_type: QuicFrameTypeName::PathResponse, + data, + } + } + + pub fn connection_close( + error_space: ErrorSpace, error_code: u64, raw_error_code: u64, + reason: String, trigger_frame_type: Option<String>, + ) -> Self { + QuicFrame::ConnectionClose { + frame_type: QuicFrameTypeName::ConnectionClose, + error_space, + error_code, + raw_error_code, + reason, + trigger_frame_type, + } + } + + pub fn handshake_done() -> Self { + QuicFrame::HandshakeDone { + frame_type: QuicFrameTypeName::HandshakeDone, + } + } + + pub fn datagram(length: String, raw: Option<String>) -> Self { + QuicFrame::Datagram { + frame_type: QuicFrameTypeName::Datagram, + length, + raw, + } + } + + pub fn unknown(raw_frame_type: u64) -> Self { + QuicFrame::Unknown { + frame_type: QuicFrameTypeName::Unknown, + raw_frame_type, + } + } +} + +// ================================================================== // +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum Http3FrameTypeName { + Data, + Headers, + CancelPush, + Settings, + PushPromise, + Goaway, + MaxPushId, + DuplicatePush, + Reserved, + Unknown, +} + +#[derive(Serialize, Clone)] +pub struct HttpHeader { + pub name: String, + pub value: String, +} + +#[derive(Serialize, Clone)] +pub struct Setting { + pub name: String, + pub value: String, +} + +#[derive(Serialize, Clone)] +pub enum Http3Frame { + Data { + frame_type: Http3FrameTypeName, + + raw: Option<String>, + }, + + Headers { + frame_type: Http3FrameTypeName, + headers: Vec<HttpHeader>, + }, + + CancelPush { + frame_type: Http3FrameTypeName, + push_id: String, + }, + + Settings { + frame_type: Http3FrameTypeName, + settings: Vec<Setting>, + }, + + PushPromise { + frame_type: Http3FrameTypeName, + push_id: String, + headers: Vec<HttpHeader>, + }, + + Goaway { + frame_type: Http3FrameTypeName, + stream_id: String, + }, + + MaxPushId { + frame_type: Http3FrameTypeName, + push_id: String, + }, + + DuplicatePush { + frame_type: Http3FrameTypeName, + push_id: String, + }, + + Reserved { + frame_type: Http3FrameTypeName, + }, + + Unknown { + frame_type: Http3FrameTypeName, + }, +} + +impl Http3Frame { + pub fn data(raw: Option<String>) -> Self { + Http3Frame::Data { + frame_type: Http3FrameTypeName::Data, + raw, + } + } + + pub fn headers(headers: Vec<HttpHeader>) -> Self { + Http3Frame::Headers { + frame_type: Http3FrameTypeName::Headers, + headers, + } + } + + pub fn cancel_push(push_id: String) -> Self { + Http3Frame::CancelPush { + frame_type: Http3FrameTypeName::CancelPush, + push_id, + } + } + + pub fn settings(settings: Vec<Setting>) -> Self { + Http3Frame::Settings { + frame_type: Http3FrameTypeName::Settings, + settings, + } + } + + pub fn push_promise(push_id: String, headers: Vec<HttpHeader>) -> Self { + Http3Frame::PushPromise { + frame_type: Http3FrameTypeName::PushPromise, + push_id, + headers, + } + } + + pub fn goaway(stream_id: String) -> Self { + Http3Frame::Goaway { + frame_type: Http3FrameTypeName::Goaway, + stream_id, + } + } + + pub fn max_push_id(push_id: String) -> Self { + Http3Frame::MaxPushId { + frame_type: Http3FrameTypeName::MaxPushId, + push_id, + } + } + + pub fn duplicate_push(push_id: String) -> Self { + Http3Frame::DuplicatePush { + frame_type: Http3FrameTypeName::DuplicatePush, + push_id, + } + } + + pub fn reserved() -> Self { + Http3Frame::Reserved { + frame_type: Http3FrameTypeName::Reserved, + } + } + + pub fn unknown() -> Self { + Http3Frame::Unknown { + frame_type: Http3FrameTypeName::Unknown, + } + } +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackInstructionTypeName { + SetDynamicTableCapacityInstruction, + InsertWithNameReferenceInstruction, + InsertWithoutNameReferenceInstruction, + DuplicateInstruction, + HeaderAcknowledgementInstruction, + StreamCancellationInstruction, + InsertCountIncrementInstruction, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackTableType { + Static, + Dynamic, +} + +#[derive(Serialize, Clone)] +pub enum QPackInstruction { + SetDynamicTableCapacityInstruction { + instruction_type: QpackInstructionTypeName, + + capacity: u64, + }, + + InsertWithNameReferenceInstruction { + instruction_type: QpackInstructionTypeName, + + table_type: QpackTableType, + + name_index: u64, + + huffman_encoded_value: bool, + value_length: u64, + value: String, + }, + + InsertWithoutNameReferenceInstruction { + instruction_type: QpackInstructionTypeName, + + huffman_encoded_name: bool, + name_length: u64, + name: String, + + huffman_encoded_value: bool, + value_length: u64, + value: String, + }, + + DuplicateInstruction { + instruction_type: QpackInstructionTypeName, + + index: u64, + }, + + HeaderAcknowledgementInstruction { + instruction_type: QpackInstructionTypeName, + + stream_id: String, + }, + + StreamCancellationInstruction { + instruction_type: QpackInstructionTypeName, + + stream_id: String, + }, + + InsertCountIncrementInstruction { + instruction_type: QpackInstructionTypeName, + + increment: u64, + }, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "snake_case")] +pub enum QpackHeaderBlockRepresentationTypeName { + IndexedHeaderField, + LiteralHeaderFieldWithName, + LiteralHeaderFieldWithoutName, +} + +#[derive(Serialize, Clone)] +pub enum QpackHeaderBlockRepresentation { + IndexedHeaderField { + header_field_type: QpackHeaderBlockRepresentationTypeName, + + table_type: QpackTableType, + index: u64, + + is_post_base: Option<bool>, + }, + + LiteralHeaderFieldWithName { + header_field_type: QpackHeaderBlockRepresentationTypeName, + + preserve_literal: bool, + table_type: QpackTableType, + name_index: u64, + + huffman_encoded_value: bool, + value_length: u64, + value: String, + + is_post_base: Option<bool>, + }, + + LiteralHeaderFieldWithoutName { + header_field_type: QpackHeaderBlockRepresentationTypeName, + + preserve_literal: bool, + table_type: QpackTableType, + name_index: u64, + + huffman_encoded_name: bool, + name_length: u64, + name: String, + + huffman_encoded_value: bool, + value_length: u64, + value: String, + + is_post_base: Option<bool>, + }, +} + +pub struct HexSlice<'a>(&'a [u8]); + +impl<'a> HexSlice<'a> { + pub fn new<T>(data: &'a T) -> HexSlice<'a> + where + T: ?Sized + AsRef<[u8]> + 'a, + { + HexSlice(data.as_ref()) + } + + pub fn maybe_string<T>(data: Option<&'a T>) -> Option<String> + where + T: ?Sized + AsRef<[u8]> + 'a, + { + match data { + Some(d) => Some(format!("{}", HexSlice::new(d))), + + None => None, + } + } +} + +impl<'a> std::fmt::Display for HexSlice<'a> { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + for byte in self.0 { + write!(f, "{:02x}", byte)?; + } + Ok(()) + } +} + +#[doc(hidden)] +pub mod testing { + use super::*; + + pub fn make_pkt_hdr() -> PacketHeader { + let scid = [0x7e, 0x37, 0xe4, 0xdc, 0xc6, 0x68, 0x2d, 0xa8]; + let dcid = [0x36, 0xce, 0x10, 0x4e, 0xee, 0x50, 0x10, 0x1c]; + + PacketHeader::new( + 0, + Some(1251), + Some(1224), + Some(0xff00_0018), + Some(&scid), + Some(&dcid), + ) + } + + pub fn make_trace() -> Trace { + Trace::new( + VantagePoint { + name: None, + ty: VantagePointType::Server, + flow: None, + }, + Some("Quiche qlog trace".to_string()), + Some("Quiche qlog trace description".to_string()), + Some(Configuration { + time_offset: Some("0".to_string()), + time_units: Some(TimeUnits::Ms), + original_uris: None, + }), + None, + ) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use testing::*; + + #[test] + fn packet_header() { + let pkt_hdr = make_pkt_hdr(); + + let log_string = r#"{ + "packet_number": "0", + "packet_size": 1251, + "payload_length": 1224, + "version": "ff000018", + "scil": "8", + "dcil": "8", + "scid": "7e37e4dcc6682da8", + "dcid": "36ce104eee50101c" +}"#; + + assert_eq!(serde_json::to_string_pretty(&pkt_hdr).unwrap(), log_string); + } + + #[test] + fn packet_sent_event_no_frames() { + let log_string = r#"{ + "packet_type": "initial", + "header": { + "packet_number": "0", + "packet_size": 1251, + "payload_length": 1224, + "version": "ff00001b", + "scil": "8", + "dcil": "8", + "scid": "7e37e4dcc6682da8", + "dcid": "36ce104eee50101c" + } +}"#; + + let scid = [0x7e, 0x37, 0xe4, 0xdc, 0xc6, 0x68, 0x2d, 0xa8]; + let dcid = [0x36, 0xce, 0x10, 0x4e, 0xee, 0x50, 0x10, 0x1c]; + let pkt_hdr = PacketHeader::new( + 0, + Some(1251), + Some(1224), + Some(0xff00001b), + Some(&scid), + Some(&dcid), + ); + + let pkt_sent_evt = EventData::PacketSent { + raw_encrypted: None, + raw_decrypted: None, + packet_type: PacketType::Initial, + header: pkt_hdr.clone(), + frames: None, + is_coalesced: None, + }; + + assert_eq!( + serde_json::to_string_pretty(&pkt_sent_evt).unwrap(), + log_string + ); + } + + #[test] + fn packet_sent_event_some_frames() { + let log_string = r#"{ + "packet_type": "initial", + "header": { + "packet_number": "0", + "packet_size": 1251, + "payload_length": 1224, + "version": "ff000018", + "scil": "8", + "dcil": "8", + "scid": "7e37e4dcc6682da8", + "dcid": "36ce104eee50101c" + }, + "frames": [ + { + "frame_type": "padding" + }, + { + "frame_type": "ping" + }, + { + "frame_type": "stream", + "stream_id": "0", + "offset": "0", + "length": "100", + "fin": true + } + ] +}"#; + + let pkt_hdr = make_pkt_hdr(); + + let mut frames = Vec::new(); + frames.push(QuicFrame::padding()); + + frames.push(QuicFrame::ping()); + + frames.push(QuicFrame::stream( + "0".to_string(), + "0".to_string(), + "100".to_string(), + true, + None, + )); + + let pkt_sent_evt = EventData::PacketSent { + raw_encrypted: None, + raw_decrypted: None, + packet_type: PacketType::Initial, + header: pkt_hdr.clone(), + frames: Some(frames), + is_coalesced: None, + }; + + assert_eq!( + serde_json::to_string_pretty(&pkt_sent_evt).unwrap(), + log_string + ); + } + + #[test] + fn trace_no_events() { + let log_string = r#"{ + "vantage_point": { + "type": "server" + }, + "title": "Quiche qlog trace", + "description": "Quiche qlog trace description", + "configuration": { + "time_units": "ms", + "time_offset": "0" + }, + "event_fields": [ + "relative_time", + "category", + "event", + "data" + ], + "events": [] +}"#; + + let trace = make_trace(); + + assert_eq!(serde_json::to_string_pretty(&trace).unwrap(), log_string); + } + + #[test] + fn trace_single_transport_event() { + let log_string = r#"{ + "vantage_point": { + "type": "server" + }, + "title": "Quiche qlog trace", + "description": "Quiche qlog trace description", + "configuration": { + "time_units": "ms", + "time_offset": "0" + }, + "event_fields": [ + "relative_time", + "category", + "event", + "data" + ], + "events": [ + [ + "0", + "transport", + "packet_sent", + { + "packet_type": "initial", + "header": { + "packet_number": "0", + "packet_size": 1251, + "payload_length": 1224, + "version": "ff000018", + "scil": "8", + "dcil": "8", + "scid": "7e37e4dcc6682da8", + "dcid": "36ce104eee50101c" + }, + "frames": [ + { + "frame_type": "stream", + "stream_id": "0", + "offset": "0", + "length": "100", + "fin": true + } + ] + } + ] + ] +}"#; + + let mut trace = make_trace(); + + let pkt_hdr = make_pkt_hdr(); + + let frames = vec![QuicFrame::stream( + "0".to_string(), + "0".to_string(), + "100".to_string(), + true, + None, + )]; + let event = event::Event::packet_sent_min( + PacketType::Initial, + pkt_hdr, + Some(frames), + ); + + trace.push_event(std::time::Duration::new(0, 0), event); + + assert_eq!(serde_json::to_string_pretty(&trace).unwrap(), log_string); + } + + #[test] + fn test_event_validity() { + // Test a single event in each category + + let ev = event::Event::server_listening_min(443, 443); + assert!(ev.is_valid()); + + let ev = event::Event::transport_parameters_set_min(); + assert!(ev.is_valid()); + + let ev = event::Event::recovery_parameters_set_min(); + assert!(ev.is_valid()); + + let ev = event::Event::h3_parameters_set_min(); + assert!(ev.is_valid()); + + let ev = event::Event::qpack_state_updated_min(); + assert!(ev.is_valid()); + + let ev = event::Event { + category: EventCategory::Error, + ty: EventType::GenericEventType(GenericEventType::ConnectionError), + data: EventData::ConnectionError { + code: None, + description: None, + }, + }; + + assert!(ev.is_valid()); + } + + #[test] + fn bogus_event_validity() { + // Test a single event in each category + + let mut ev = event::Event::server_listening_min(443, 443); + ev.category = EventCategory::Simulation; + assert!(!ev.is_valid()); + + let mut ev = event::Event::transport_parameters_set_min(); + ev.category = EventCategory::Simulation; + assert!(!ev.is_valid()); + + let mut ev = event::Event::recovery_parameters_set_min(); + ev.category = EventCategory::Simulation; + assert!(!ev.is_valid()); + + let mut ev = event::Event::h3_parameters_set_min(); + ev.category = EventCategory::Simulation; + assert!(!ev.is_valid()); + + let mut ev = event::Event::qpack_state_updated_min(); + ev.category = EventCategory::Simulation; + assert!(!ev.is_valid()); + + let ev = event::Event { + category: EventCategory::Error, + ty: EventType::GenericEventType(GenericEventType::ConnectionError), + data: EventData::FramesProcessed { frames: Vec::new() }, + }; + + assert!(!ev.is_valid()); + } + + #[test] + fn serialization_states() { + let v: Vec<u8> = Vec::new(); + let buff = std::io::Cursor::new(v); + let writer = Box::new(buff); + + let mut trace = make_trace(); + let pkt_hdr = make_pkt_hdr(); + + let frame1 = QuicFrame::stream( + "40".to_string(), + "40".to_string(), + "400".to_string(), + true, + None, + ); + + let event1 = event::Event::packet_sent_min( + PacketType::Handshake, + pkt_hdr.clone(), + Some(vec![frame1]), + ); + + trace.push_event(std::time::Duration::new(0, 0), event1); + + let frame2 = QuicFrame::stream( + "0".to_string(), + "0".to_string(), + "100".to_string(), + true, + None, + ); + + let frame3 = QuicFrame::stream( + "0".to_string(), + "0".to_string(), + "100".to_string(), + true, + None, + ); + + let event2 = event::Event::packet_sent_min( + PacketType::Initial, + pkt_hdr.clone(), + Some(Vec::new()), + ); + + let event3 = event::Event::packet_sent( + PacketType::Initial, + pkt_hdr, + Some(Vec::new()), + None, + Some("encrypted_foo".to_string()), + Some("decrypted_foo".to_string()), + ); + + let mut s = QlogStreamer::new( + "version".to_string(), + Some("title".to_string()), + Some("description".to_string()), + None, + std::time::Instant::now(), + trace, + writer, + ); + + // Before the log is started all other operations should fail. + assert!(match s.add_event(event2.clone()) { + Err(Error::InvalidState) => true, + _ => false, + }); + assert!(match s.add_frame(frame2.clone(), false) { + Err(Error::InvalidState) => true, + _ => false, + }); + assert!(match s.finish_frames() { + Err(Error::InvalidState) => true, + _ => false, + }); + assert!(match s.finish_log() { + Err(Error::InvalidState) => true, + _ => false, + }); + + // Once a log is started, can't write frames before an event. + assert!(match s.start_log() { + Ok(()) => true, + _ => false, + }); + assert!(match s.add_frame(frame2.clone(), true) { + Err(Error::InvalidState) => true, + _ => false, + }); + assert!(match s.finish_frames() { + Err(Error::InvalidState) => true, + _ => false, + }); + + // Some events hold frames; can't write any more events until frame + // writing is concluded. + assert!(match s.add_event(event2.clone()) { + Ok(true) => true, + _ => false, + }); + assert!(match s.add_event(event2.clone()) { + Err(Error::InvalidState) => true, + _ => false, + }); + + // While writing frames, can't write events. + assert!(match s.add_frame(frame2.clone(), false) { + Ok(()) => true, + _ => false, + }); + + assert!(match s.add_event(event2.clone()) { + Err(Error::InvalidState) => true, + _ => false, + }); + assert!(match s.finish_frames() { + Ok(()) => true, + _ => false, + }); + + // Adding an event that includes both frames and raw data should + // be allowed. + assert!(match s.add_event(event3.clone()) { + Ok(true) => true, + _ => false, + }); + assert!(match s.add_frame(frame3.clone(), false) { + Ok(()) => true, + _ => false, + }); + assert!(match s.finish_frames() { + Ok(()) => true, + _ => false, + }); + + assert!(match s.finish_log() { + Ok(()) => true, + _ => false, + }); + + let r = s.writer(); + let w: &Box<std::io::Cursor<Vec<u8>>> = unsafe { std::mem::transmute(r) }; + + let log_string = r#"{"qlog_version":"version","title":"title","description":"description","traces":[{"vantage_point":{"type":"server"},"title":"Quiche qlog trace","description":"Quiche qlog trace description","configuration":{"time_units":"ms","time_offset":"0"},"event_fields":["relative_time","category","event","data"],"events":[["0","transport","packet_sent",{"packet_type":"handshake","header":{"packet_number":"0","packet_size":1251,"payload_length":1224,"version":"ff000018","scil":"8","dcil":"8","scid":"7e37e4dcc6682da8","dcid":"36ce104eee50101c"},"frames":[{"frame_type":"stream","stream_id":"40","offset":"40","length":"400","fin":true}]}],["0","transport","packet_sent",{"packet_type":"initial","header":{"packet_number":"0","packet_size":1251,"payload_length":1224,"version":"ff000018","scil":"8","dcil":"8","scid":"7e37e4dcc6682da8","dcid":"36ce104eee50101c"},"frames":[{"frame_type":"stream","stream_id":"0","offset":"0","length":"100","fin":true}]}],["0","transport","packet_sent",{"packet_type":"initial","header":{"packet_number":"0","packet_size":1251,"payload_length":1224,"version":"ff000018","scil":"8","dcil":"8","scid":"7e37e4dcc6682da8","dcid":"36ce104eee50101c"},"raw_encrypted":"encrypted_foo","raw_decrypted":"decrypted_foo","frames":[{"frame_type":"stream","stream_id":"0","offset":"0","length":"100","fin":true}]}]]}]}"#; + + let written_string = std::str::from_utf8(w.as_ref().get_ref()).unwrap(); + + assert_eq!(log_string, written_string); + } +} + +pub mod event; |