Merging upstream version 127.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 42 insertions, 31 deletions

diff --git a/third_party/rust/neqo-transport/src/qlog.rs b/third_party/rust/neqo-transport/src/qlog.rs
index a8ad986d2a..715ba85e81 100644
--- a/third_party/rust/neqo-transport/src/qlog.rs
+++ b/third_party/rust/neqo-transport/src/qlog.rs
@@ -11,7 +11,7 @@ use std::{
     time::Duration,
 };
 
-use neqo_common::{hex, qinfo, qlog::NeqoQlog, Decoder};
+use neqo_common::{hex, qinfo, qlog::NeqoQlog, Decoder, IpTosEcn};
 use qlog::events::{
     connectivity::{ConnectionStarted, ConnectionState, ConnectionStateUpdated},
     quic::{
@@ -205,7 +205,7 @@ pub fn packet_sent(
         let mut frames = SmallVec::new();
         while d.remaining() > 0 {
             if let Ok(f) = Frame::decode(&mut d) {
-                frames.push(QuicFrame::from(&f));
+                frames.push(QuicFrame::from(f));
             } else {
                 qinfo!("qlog: invalid frame");
                 break;
@@ -293,7 +293,7 @@ pub fn packet_received(
 
         while d.remaining() > 0 {
             if let Ok(f) = Frame::decode(&mut d) {
-                frames.push(QuicFrame::from(&f));
+                frames.push(QuicFrame::from(f));
             } else {
                 qinfo!("qlog: invalid frame");
                 break;
@@ -387,21 +387,26 @@ pub fn metrics_updated(qlog: &mut NeqoQlog, updated_metrics: &[QlogMetric]) {
 
 #[allow(clippy::too_many_lines)] // Yeah, but it's a nice match.
 #[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)] // No choice here.
-impl From<&Frame<'_>> for QuicFrame {
-    fn from(frame: &Frame) -> Self {
+impl From<Frame<'_>> for QuicFrame {
+    fn from(frame: Frame) -> Self {
         match frame {
-            // TODO: Add payload length to `QuicFrame::Padding` once
-            // https://github.com/cloudflare/quiche/pull/1745 is available via the qlog crate.
-            Frame::Padding { .. } => QuicFrame::Padding,
-            Frame::Ping => QuicFrame::Ping,
+            Frame::Padding(len) => QuicFrame::Padding {
+                length: None,
+                payload_length: u32::from(len),
+            },
+            Frame::Ping => QuicFrame::Ping {
+                length: None,
+                payload_length: None,
+            },
             Frame::Ack {
                 largest_acknowledged,
                 ack_delay,
                 first_ack_range,
                 ack_ranges,
+                ecn_count,
             } => {
                 let ranges =
-                    Frame::decode_ack_frame(*largest_acknowledged, *first_ack_range, ack_ranges)
+                    Frame::decode_ack_frame(largest_acknowledged, first_ack_range, &ack_ranges)
                         .ok();
 
                 let acked_ranges = ranges.map(|all| {
@@ -413,11 +418,13 @@ impl From<&Frame<'_>> for QuicFrame {
                 });
 
                 QuicFrame::Ack {
-                    ack_delay: Some(*ack_delay as f32 / 1000.0),
+                    ack_delay: Some(ack_delay as f32 / 1000.0),
                     acked_ranges,
-                    ect1: None,
-                    ect0: None,
-                    ce: None,
+                    ect1: ecn_count.map(|c| c[IpTosEcn::Ect1]),
+                    ect0: ecn_count.map(|c| c[IpTosEcn::Ect0]),
+                    ce: ecn_count.map(|c| c[IpTosEcn::Ce]),
+                    length: None,
+                    payload_length: None,
                 }
             }
             Frame::ResetStream {
@@ -426,18 +433,22 @@ impl From<&Frame<'_>> for QuicFrame {
                 final_size,
             } => QuicFrame::ResetStream {
                 stream_id: stream_id.as_u64(),
-                error_code: *application_error_code,
-                final_size: *final_size,
+                error_code: application_error_code,
+                final_size,
+                length: None,
+                payload_length: None,
             },
             Frame::StopSending {
                 stream_id,
                 application_error_code,
             } => QuicFrame::StopSending {
                 stream_id: stream_id.as_u64(),
-                error_code: *application_error_code,
+                error_code: application_error_code,
+                length: None,
+                payload_length: None,
             },
             Frame::Crypto { offset, data } => QuicFrame::Crypto {
-                offset: *offset,
+                offset,
                 length: data.len() as u64,
             },
             Frame::NewToken { token } => QuicFrame::NewToken {
@@ -459,20 +470,20 @@ impl From<&Frame<'_>> for QuicFrame {
                 ..
             } => QuicFrame::Stream {
                 stream_id: stream_id.as_u64(),
-                offset: *offset,
+                offset,
                 length: data.len() as u64,
-                fin: Some(*fin),
+                fin: Some(fin),
                 raw: None,
             },
             Frame::MaxData { maximum_data } => QuicFrame::MaxData {
-                maximum: *maximum_data,
+                maximum: maximum_data,
             },
             Frame::MaxStreamData {
                 stream_id,
                 maximum_stream_data,
             } => QuicFrame::MaxStreamData {
                 stream_id: stream_id.as_u64(),
-                maximum: *maximum_stream_data,
+                maximum: maximum_stream_data,
             },
             Frame::MaxStreams {
                 stream_type,
@@ -482,15 +493,15 @@ impl From<&Frame<'_>> for QuicFrame {
                     NeqoStreamType::BiDi => StreamType::Bidirectional,
                     NeqoStreamType::UniDi => StreamType::Unidirectional,
                 },
-                maximum: *maximum_streams,
+                maximum: maximum_streams,
             },
-            Frame::DataBlocked { data_limit } => QuicFrame::DataBlocked { limit: *data_limit },
+            Frame::DataBlocked { data_limit } => QuicFrame::DataBlocked { limit: data_limit },
             Frame::StreamDataBlocked {
                 stream_id,
                 stream_data_limit,
             } => QuicFrame::StreamDataBlocked {
                 stream_id: stream_id.as_u64(),
-                limit: *stream_data_limit,
+                limit: stream_data_limit,
             },
             Frame::StreamsBlocked {
                 stream_type,
@@ -500,7 +511,7 @@ impl From<&Frame<'_>> for QuicFrame {
                     NeqoStreamType::BiDi => StreamType::Bidirectional,
                     NeqoStreamType::UniDi => StreamType::Unidirectional,
                 },
-                limit: *stream_limit,
+                limit: stream_limit,
             },
             Frame::NewConnectionId {
                 sequence_number,
@@ -508,14 +519,14 @@ impl From<&Frame<'_>> for QuicFrame {
                 connection_id,
                 stateless_reset_token,
             } => QuicFrame::NewConnectionId {
-                sequence_number: *sequence_number as u32,
-                retire_prior_to: *retire_prior as u32,
+                sequence_number: sequence_number as u32,
+                retire_prior_to: retire_prior as u32,
                 connection_id_length: Some(connection_id.len() as u8),
                 connection_id: hex(connection_id),
                 stateless_reset_token: Some(hex(stateless_reset_token)),
             },
             Frame::RetireConnectionId { sequence_number } => QuicFrame::RetireConnectionId {
-                sequence_number: *sequence_number as u32,
+                sequence_number: sequence_number as u32,
             },
             Frame::PathChallenge { data } => QuicFrame::PathChallenge {
                 data: Some(hex(data)),
@@ -534,8 +545,8 @@ impl From<&Frame<'_>> for QuicFrame {
                 },
                 error_code: Some(error_code.code()),
                 error_code_value: Some(0),
-                reason: Some(String::from_utf8_lossy(reason_phrase).to_string()),
-                trigger_frame_type: Some(*frame_type),
+                reason: Some(reason_phrase),
+                trigger_frame_type: Some(frame_type),
             },
             Frame::HandshakeDone => QuicFrame::HandshakeDone,
             Frame::AckFrequency { .. } => QuicFrame::Unknown {