1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
//! Extensions for the HTTP/3 protocol.
use std::convert::TryFrom;
use std::str::FromStr;
use bytes::{Buf, Bytes};
use crate::{
error::Code,
proto::{stream::StreamId, varint::VarInt},
Error,
};
/// Describes the `:protocol` pseudo-header for extended connect
///
/// See: <https://www.rfc-editor.org/rfc/rfc8441#section-4>
#[derive(Copy, PartialEq, Debug, Clone)]
pub struct Protocol(ProtocolInner);
impl Protocol {
/// WebTransport protocol
pub const WEB_TRANSPORT: Protocol = Protocol(ProtocolInner::WebTransport);
}
#[derive(Copy, PartialEq, Debug, Clone)]
enum ProtocolInner {
WebTransport,
}
/// Error when parsing the protocol
pub struct InvalidProtocol;
impl FromStr for Protocol {
type Err = InvalidProtocol;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"webtransport" => Ok(Self(ProtocolInner::WebTransport)),
_ => Err(InvalidProtocol),
}
}
}
/// HTTP datagram frames
/// See: <https://www.rfc-editor.org/rfc/rfc9297#section-2.1>
pub struct Datagram<B = Bytes> {
/// Stream id divided by 4
stream_id: StreamId,
/// The data contained in the datagram
payload: B,
}
impl<B> Datagram<B>
where
B: Buf,
{
/// Creates a new datagram frame
pub fn new(stream_id: StreamId, payload: B) -> Self {
assert!(
stream_id.into_inner() % 4 == 0,
"StreamId is not divisible by 4"
);
Self { stream_id, payload }
}
/// Decodes a datagram frame from the QUIC datagram
pub fn decode(mut buf: B) -> Result<Self, Error> {
let q_stream_id = VarInt::decode(&mut buf)
.map_err(|_| Code::H3_DATAGRAM_ERROR.with_cause("Malformed datagram frame"))?;
//= https://www.rfc-editor.org/rfc/rfc9297#section-2.1
// Quarter Stream ID: A variable-length integer that contains the value of the client-initiated bidirectional
// stream that this datagram is associated with divided by four (the division by four stems
// from the fact that HTTP requests are sent on client-initiated bidirectional streams,
// which have stream IDs that are divisible by four). The largest legal QUIC stream ID
// value is 262-1, so the largest legal value of the Quarter Stream ID field is 260-1.
// Receipt of an HTTP/3 Datagram that includes a larger value MUST be treated as an HTTP/3
// connection error of type H3_DATAGRAM_ERROR (0x33).
let stream_id = StreamId::try_from(u64::from(q_stream_id) * 4)
.map_err(|_| Code::H3_DATAGRAM_ERROR.with_cause("Invalid stream id"))?;
let payload = buf;
Ok(Self { stream_id, payload })
}
#[inline]
/// Returns the associated stream id of the datagram
pub fn stream_id(&self) -> StreamId {
self.stream_id
}
#[inline]
/// Returns the datagram payload
pub fn payload(&self) -> &B {
&self.payload
}
/// Encode the datagram to wire format
pub fn encode<D: bytes::BufMut>(self, buf: &mut D) {
(VarInt::from(self.stream_id) / 4).encode(buf);
buf.put(self.payload);
}
/// Returns the datagram payload
pub fn into_payload(self) -> B {
self.payload
}
}