web_transport_noq/
connect.rs1use std::ops::Deref;
2
3use web_transport_proto::{ConnectRequest, ConnectResponse, VarInt};
4
5use thiserror::Error;
6
7#[derive(Error, Debug, Clone)]
8pub enum ConnectError {
9 #[error("quic stream was closed early")]
10 UnexpectedEnd,
11
12 #[error("protocol error: {0}")]
13 ProtoError(#[from] web_transport_proto::ConnectError),
14
15 #[error("connection error")]
16 ConnectionError(#[from] noq::ConnectionError),
17
18 #[error("read error")]
19 ReadError(#[from] noq::ReadError),
20
21 #[error("write error")]
22 WriteError(#[from] noq::WriteError),
23
24 #[error("http error status: {0}")]
25 ErrorStatus(http::StatusCode),
26
27 #[error("server returned protocol not in request: {0}")]
28 ProtocolMismatch(String),
29}
30
31pub struct Connecting {
33 pub request: ConnectRequest,
35
36 pub(crate) send: noq::SendStream,
38 pub(crate) recv: noq::RecvStream,
39}
40
41impl Connecting {
42 pub async fn accept(conn: &noq::Connection) -> Result<Self, ConnectError> {
43 let (send, mut recv) = conn.accept_bi().await?;
46
47 let request = web_transport_proto::ConnectRequest::read(&mut recv).await?;
48 tracing::debug!(?request, "received CONNECT request");
49
50 Ok(Self {
52 request,
53 send,
54 recv,
55 })
56 }
57
58 pub async fn respond(
60 mut self,
61 response: impl Into<ConnectResponse>,
62 ) -> Result<Connected, ConnectError> {
63 let response = response.into();
64
65 if let Some(protocol) = &response.protocol {
67 if !self.request.protocols.contains(protocol) {
68 return Err(ConnectError::ProtocolMismatch(protocol.clone()));
69 }
70 }
71
72 tracing::debug!(?response, "sending CONNECT response");
73 response.write(&mut self.send).await?;
74
75 Ok(Connected {
76 request: self.request,
77 response,
78 send: self.send,
79 recv: self.recv,
80 })
81 }
82
83 pub async fn reject(self, status: http::StatusCode) -> Result<(), ConnectError> {
84 let mut connect = self.respond(status).await?;
85 connect.send.finish().ok();
86 Ok(())
87 }
88}
89
90impl Deref for Connecting {
91 type Target = ConnectRequest;
92
93 fn deref(&self) -> &Self::Target {
94 &self.request
95 }
96}
97
98pub struct Connected {
99 pub request: ConnectRequest,
101
102 pub response: ConnectResponse,
104
105 pub(crate) send: noq::SendStream,
107 pub(crate) recv: noq::RecvStream,
108}
109
110impl Connected {
111 pub async fn open(
116 conn: &noq::Connection,
117 request: impl Into<ConnectRequest>,
118 ) -> Result<Self, ConnectError> {
119 let request = request.into();
120
121 let (mut send, mut recv) = conn.open_bi().await?;
123
124 tracing::debug!(?request, "sending CONNECT request");
125 request.write(&mut send).await?;
126
127 let response = web_transport_proto::ConnectResponse::read(&mut recv).await?;
128 tracing::debug!(?response, "received CONNECT response");
129
130 if response.status != http::StatusCode::OK {
132 return Err(ConnectError::ErrorStatus(response.status));
133 }
134
135 if let Some(protocol) = &response.protocol {
137 if !request.protocols.contains(protocol) {
138 return Err(ConnectError::ProtocolMismatch(protocol.clone()));
139 }
140 }
141
142 Ok(Self {
143 request,
144 response,
145 send,
146 recv,
147 })
148 }
149
150 pub fn session_id(&self) -> VarInt {
152 let stream_id = noq::VarInt::from(self.send.id());
155 VarInt::try_from(stream_id.into_inner()).unwrap()
156 }
157}