noq/
incoming.rs

1use std::{
2    future::{Future, IntoFuture},
3    net::{IpAddr, SocketAddr},
4    pin::Pin,
5    sync::Arc,
6    task::{Context, Poll},
7};
8
9use proto::{ConnectionError, ConnectionId, DecryptedInitial, ServerConfig};
10use thiserror::Error;
11
12use crate::{
13    connection::{Connecting, Connection},
14    endpoint::EndpointRef,
15};
16
17/// An incoming connection for which the server has not yet begun its part of the handshake
18#[derive(Debug)]
19pub struct Incoming(Option<State>);
20
21impl Incoming {
22    pub(crate) fn new(inner: proto::Incoming, endpoint: EndpointRef) -> Self {
23        Self(Some(State { inner, endpoint }))
24    }
25
26    /// Attempt to accept this incoming connection (an error may still occur)
27    pub fn accept(mut self) -> Result<Connecting, ConnectionError> {
28        let state = self.0.take().unwrap();
29        state.endpoint.accept(state.inner, None)
30    }
31
32    /// Accept this incoming connection using a custom configuration
33    ///
34    /// See [`accept()`][Incoming::accept] for more details.
35    pub fn accept_with(
36        mut self,
37        server_config: Arc<ServerConfig>,
38    ) -> Result<Connecting, ConnectionError> {
39        let state = self.0.take().unwrap();
40        state.endpoint.accept(state.inner, Some(server_config))
41    }
42
43    /// Reject this incoming connection attempt
44    pub fn refuse(mut self) {
45        let state = self.0.take().unwrap();
46        state.endpoint.refuse(state.inner);
47    }
48
49    /// Respond with a retry packet, requiring the client to retry with address validation
50    ///
51    /// Errors if `may_retry()` is false.
52    pub fn retry(mut self) -> Result<(), RetryError> {
53        let state = self.0.take().unwrap();
54        state.endpoint.retry(state.inner).map_err(|e| {
55            RetryError(Box::new(Self(Some(State {
56                inner: e.into_incoming(),
57                endpoint: state.endpoint,
58            }))))
59        })
60    }
61
62    /// Ignore this incoming connection attempt, not sending any packet in response
63    pub fn ignore(mut self) {
64        let state = self.0.take().unwrap();
65        state.endpoint.ignore(state.inner);
66    }
67
68    /// The local IP address which was used when the peer established the connection
69    pub fn local_ip(&self) -> Option<IpAddr> {
70        self.0.as_ref().unwrap().inner.local_ip()
71    }
72
73    /// The peer's UDP address
74    pub fn remote_address(&self) -> SocketAddr {
75        self.0.as_ref().unwrap().inner.remote_address()
76    }
77
78    /// Whether the socket address that is initiating this connection has been validated
79    ///
80    /// This means that the sender of the initial packet has proved that they can receive traffic
81    /// sent to `self.remote_address()`.
82    ///
83    /// If `self.remote_address_validated()` is false, `self.may_retry()` is guaranteed to be true.
84    /// The inverse is not guaranteed.
85    pub fn remote_address_validated(&self) -> bool {
86        self.0.as_ref().unwrap().inner.remote_address_validated()
87    }
88
89    /// Whether it is legal to respond with a retry packet
90    ///
91    /// If `self.remote_address_validated()` is false, `self.may_retry()` is guaranteed to be true.
92    /// The inverse is not guaranteed.
93    pub fn may_retry(&self) -> bool {
94        self.0.as_ref().unwrap().inner.may_retry()
95    }
96
97    /// The original destination CID when initiating the connection
98    pub fn orig_dst_cid(&self) -> ConnectionId {
99        self.0.as_ref().unwrap().inner.orig_dst_cid()
100    }
101
102    /// Decrypt the Initial packet payload
103    ///
104    /// This clones and decrypts the packet payload (~1200 bytes).
105    /// Can be used to extract information from the TLS ClientHello without completing the handshake.
106    pub fn decrypt(&self) -> Option<DecryptedInitial> {
107        self.0.as_ref()?.inner.decrypt()
108    }
109}
110
111impl Drop for Incoming {
112    fn drop(&mut self) {
113        // Implicit reject, similar to Connection's implicit close
114        if let Some(state) = self.0.take() {
115            state.endpoint.refuse(state.inner);
116        }
117    }
118}
119
120#[derive(Debug)]
121struct State {
122    inner: proto::Incoming,
123    endpoint: EndpointRef,
124}
125
126/// Error for attempting to retry an [`Incoming`] which already bears a token from a previous retry
127#[derive(Debug, Error)]
128#[error("retry() with validated Incoming")]
129pub struct RetryError(Box<Incoming>);
130
131impl RetryError {
132    /// Get the [`Incoming`]
133    pub fn into_incoming(self) -> Incoming {
134        *self.0
135    }
136}
137
138/// Basic adapter to let [`Incoming`] be `await`-ed like a [`Connecting`]
139#[derive(Debug)]
140pub struct IncomingFuture(Result<Connecting, ConnectionError>);
141
142impl Future for IncomingFuture {
143    type Output = Result<Connection, ConnectionError>;
144
145    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
146        match &mut self.0 {
147            Ok(connecting) => Pin::new(connecting).poll(cx),
148            Err(e) => Poll::Ready(Err(e.clone())),
149        }
150    }
151}
152
153impl IntoFuture for Incoming {
154    type Output = Result<Connection, ConnectionError>;
155    type IntoFuture = IncomingFuture;
156
157    fn into_future(self) -> Self::IntoFuture {
158        IncomingFuture(self.accept())
159    }
160}
noq/incoming.rs

noq/
incoming.rs
