/rust/registry/src/index.crates.io-1949cf8c6b5b557f/qlog-0.15.2/src/events/h3.rs

Source
// Copyright (C) 2021, 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.

use serde::Deserialize;
use serde::Serialize;

use super::RawInfo;

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum H3Owner {
    Local,
    Remote,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
#[serde(rename_all = "snake_case")]
pub enum H3StreamType {
    Request,
    Control,
    Push,
    Reserved,
    #[default]
    Unknown,
    QpackEncode,
    QpackDecode,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum H3PushDecision {
    Claimed,
    Abandoned,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum H3PriorityTargetStreamType {
    Request,
    Push,
}

#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum Http3EventType {
    ParametersSet,
    ParametersRestored,
    StreamTypeSet,
    FrameCreated,
    FrameParsed,
    PushResolved,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[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,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct HttpHeader {
    pub name: String,
    pub value: String,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct Setting {
    pub name: String,
    pub value: u64,
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum Http3FrameTypeName {
    Data,
    Headers,
    CancelPush,
    Settings,
    PushPromise,
    Goaway,
    MaxPushId,
    DuplicatePush,
    Reserved,
    Unknown,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(tag = "frame_type")]
#[serde(rename_all = "snake_case")]
// Strictly, the qlog spec says that all these frame types have a frame_type
// field. But instead of making that a rust object property, just use serde to
// ensure it goes out on the wire. This means that deserialization of frames
// also works automatically.
pub enum Http3Frame {
    Data {
        raw: Option<RawInfo>,
    },

    Headers {
        headers: Vec<HttpHeader>,
    },

    CancelPush {
        push_id: u64,
    },

    Settings {
        settings: Vec<Setting>,
    },

    PushPromise {
        push_id: u64,
        headers: Vec<HttpHeader>,
    },

    Goaway {
        id: u64,
    },

    MaxPushId {
        push_id: u64,
    },

    PriorityUpdate {
        target_stream_type: H3PriorityTargetStreamType,
        prioritized_element_id: u64,
        priority_field_value: String,
    },

    Reserved {
        length: Option<u64>,
    },

    Unknown {
        frame_type_value: u64,
        raw: Option<RawInfo>,
    },
}

impl Default for Http3Frame {
    fn default() -> Self {
        Self::Unknown {
            frame_type_value: 0,
            raw: None,
        }
    }
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct H3ParametersSet {
    pub owner: Option<H3Owner>,

    #[serde(alias = "max_header_list_size")]
    pub max_field_section_size: Option<u64>,
    pub max_table_capacity: Option<u64>,
    pub blocked_streams_count: Option<u64>,
    pub enable_connect_protocol: Option<u64>,
    pub h3_datagram: Option<u64>,

    // qlog-defined
    pub waits_for_settings: Option<bool>,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct H3ParametersRestored {
    #[serde(alias = "max_header_list_size")]
    pub max_field_section_size: Option<u64>,
    pub max_table_capacity: Option<u64>,
    pub blocked_streams_count: Option<u64>,
    pub enable_connect_protocol: Option<u64>,
    pub h3_datagram: Option<u64>,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
pub struct H3StreamTypeSet {
    pub owner: Option<H3Owner>,
    pub stream_id: u64,
    pub stream_type: H3StreamType,
    pub stream_type_value: Option<u64>,
    pub associated_push_id: Option<u64>,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
pub struct H3FrameCreated {
    pub stream_id: u64,
    pub length: Option<u64>,
    pub frame: Http3Frame,

    pub raw: Option<RawInfo>,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
pub struct H3FrameParsed {
    pub stream_id: u64,
    pub length: Option<u64>,
    pub frame: Http3Frame,

    pub raw: Option<RawInfo>,
}

#[serde_with::skip_serializing_none]
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct H3PushResolved {
    push_id: Option<u64>,
    stream_id: Option<u64>,

    decision: Option<H3PushDecision>,
}

Coverage Report

Created: 2026-01-09 06:39

Line	Count	Source
1		// Copyright (C) 2021, Cloudflare, Inc.
2		// All rights reserved.
3		//
4		// Redistribution and use in source and binary forms, with or without
5		// modification, are permitted provided that the following conditions are
6		// met:
7		//
8		// * Redistributions of source code must retain the above copyright notice,
9		// this list of conditions and the following disclaimer.
10		//
11		// * Redistributions in binary form must reproduce the above copyright
12		// notice, this list of conditions and the following disclaimer in the
13		// documentation and/or other materials provided with the distribution.
14		//
15		// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
16		// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17		// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18		// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
19		// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20		// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21		// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22		// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23		// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24		// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25		// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27		use serde::Deserialize;
28		use serde::Serialize;
29
30		use super::RawInfo;
31
32		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
33		#[serde(rename_all = "snake_case")]
34		pub enum H3Owner {
35		Local,
36		Remote,
37		}
38
39		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
40		#[serde(rename_all = "snake_case")]
41		pub enum H3StreamType {
42		Request,
43		Control,
44		Push,
45		Reserved,
46		#[default]
47		Unknown,
48		QpackEncode,
49		QpackDecode,
50		}
51
52		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
53		#[serde(rename_all = "snake_case")]
54		pub enum H3PushDecision {
55		Claimed,
56		Abandoned,
57		}
58
59		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
60		#[serde(rename_all = "snake_case")]
61		pub enum H3PriorityTargetStreamType {
62		Request,
63		Push,
64		}
65
66		#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
67		#[serde(rename_all = "snake_case")]
68		pub enum Http3EventType {
69		ParametersSet,
70		ParametersRestored,
71		StreamTypeSet,
72		FrameCreated,
73		FrameParsed,
74		PushResolved,
75		}
76
77		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
78		#[serde(rename_all = "snake_case")]
79		pub enum ApplicationError {
80		HttpNoError,
81		HttpGeneralProtocolError,
82		HttpInternalError,
83		HttpRequestCancelled,
84		HttpIncompleteRequest,
85		HttpConnectError,
86		HttpFrameError,
87		HttpExcessiveLoad,
88		HttpVersionFallback,
89		HttpIdError,
90		HttpStreamCreationError,
91		HttpClosedCriticalStream,
92		HttpEarlyResponse,
93		HttpMissingSettings,
94		HttpUnexpectedFrame,
95		HttpRequestRejection,
96		HttpSettingsError,
97		Unknown,
98		}
99
100		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
101		pub struct HttpHeader {
102		pub name: String,
103		pub value: String,
104		}
105
106		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
107		pub struct Setting {
108		pub name: String,
109		pub value: u64,
110		}
111
112		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
113		#[serde(rename_all = "snake_case")]
114		pub enum Http3FrameTypeName {
115		Data,
116		Headers,
117		CancelPush,
118		Settings,
119		PushPromise,
120		Goaway,
121		MaxPushId,
122		DuplicatePush,
123		Reserved,
124		Unknown,
125		}
126
127		#[serde_with::skip_serializing_none]
128		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
129		#[serde(tag = "frame_type")]
130		#[serde(rename_all = "snake_case")]
131		// Strictly, the qlog spec says that all these frame types have a frame_type
132		// field. But instead of making that a rust object property, just use serde to
133		// ensure it goes out on the wire. This means that deserialization of frames
134		// also works automatically.
135		pub enum Http3Frame {
136		Data {
137		raw: Option<RawInfo>,
138		},
139
140		Headers {
141		headers: Vec<HttpHeader>,
142		},
143
144		CancelPush {
145		push_id: u64,
146		},
147
148		Settings {
149		settings: Vec<Setting>,
150		},
151
152		PushPromise {
153		push_id: u64,
154		headers: Vec<HttpHeader>,
155		},
156
157		Goaway {
158		id: u64,
159		},
160
161		MaxPushId {
162		push_id: u64,
163		},
164
165		PriorityUpdate {
166		target_stream_type: H3PriorityTargetStreamType,
167		prioritized_element_id: u64,
168		priority_field_value: String,
169		},
170
171		Reserved {
172		length: Option<u64>,
173		},
174
175		Unknown {
176		frame_type_value: u64,
177		raw: Option<RawInfo>,
178		},
179		}
180
181		impl Default for Http3Frame {
182	0	fn default() -> Self {
183	0	Self::Unknown {
184	0	frame_type_value: 0,
185	0	raw: None,
186	0	}
187	0	}
188		}
189
190		#[serde_with::skip_serializing_none]
191		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
192		pub struct H3ParametersSet {
193		pub owner: Option<H3Owner>,
194
195		#[serde(alias = "max_header_list_size")]
196		pub max_field_section_size: Option<u64>,
197		pub max_table_capacity: Option<u64>,
198		pub blocked_streams_count: Option<u64>,
199		pub enable_connect_protocol: Option<u64>,
200		pub h3_datagram: Option<u64>,
201
202		// qlog-defined
203		pub waits_for_settings: Option<bool>,
204		}
205
206		#[serde_with::skip_serializing_none]
207		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
208		pub struct H3ParametersRestored {
209		#[serde(alias = "max_header_list_size")]
210		pub max_field_section_size: Option<u64>,
211		pub max_table_capacity: Option<u64>,
212		pub blocked_streams_count: Option<u64>,
213		pub enable_connect_protocol: Option<u64>,
214		pub h3_datagram: Option<u64>,
215		}
216
217		#[serde_with::skip_serializing_none]
218		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
219		pub struct H3StreamTypeSet {
220		pub owner: Option<H3Owner>,
221		pub stream_id: u64,
222		pub stream_type: H3StreamType,
223		pub stream_type_value: Option<u64>,
224		pub associated_push_id: Option<u64>,
225		}
226
227		#[serde_with::skip_serializing_none]
228		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
229		pub struct H3FrameCreated {
230		pub stream_id: u64,
231		pub length: Option<u64>,
232		pub frame: Http3Frame,
233
234		pub raw: Option<RawInfo>,
235		}
236
237		#[serde_with::skip_serializing_none]
238		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug, Default)]
239		pub struct H3FrameParsed {
240		pub stream_id: u64,
241		pub length: Option<u64>,
242		pub frame: Http3Frame,
243
244		pub raw: Option<RawInfo>,
245		}
246
247		#[serde_with::skip_serializing_none]
248		#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
249		pub struct H3PushResolved {
250		push_id: Option<u64>,
251		stream_id: Option<u64>,
252
253		decision: Option<H3PushDecision>,
254		}