webrtc_dtls/
listener.rs

1use std::future::Future;
2use std::io::BufReader;
3use std::net::SocketAddr;
4use std::pin::Pin;
5use std::sync::Arc;
6
7use async_trait::async_trait;
8use tokio::net::ToSocketAddrs;
9use util::conn::conn_udp_listener::*;
10use util::conn::*;
11
12use crate::config::*;
13use crate::conn::DTLSConn;
14use crate::content::ContentType;
15use crate::error::Result;
16use crate::record_layer::record_layer_header::RecordLayerHeader;
17use crate::record_layer::unpack_datagram;
18
19/// Listen creates a DTLS listener
20pub async fn listen<A: 'static + ToSocketAddrs>(laddr: A, config: Config) -> Result<impl Listener> {
21    validate_config(false, &config)?;
22
23    let mut lc = ListenConfig {
24        accept_filter: Some(Box::new(
25            |packet: &[u8]| -> Pin<Box<dyn Future<Output = bool> + Send + 'static>> {
26                let pkts = match unpack_datagram(packet) {
27                    Ok(pkts) => {
28                        if pkts.is_empty() {
29                            return Box::pin(async { false });
30                        }
31                        pkts
32                    }
33                    Err(_) => return Box::pin(async { false }),
34                };
35
36                let mut reader = BufReader::new(pkts[0].as_slice());
37                match RecordLayerHeader::unmarshal(&mut reader) {
38                    Ok(h) => {
39                        let content_type = h.content_type;
40                        Box::pin(async move { content_type == ContentType::Handshake })
41                    }
42                    Err(_) => Box::pin(async { false }),
43                }
44            },
45        )),
46        ..Default::default()
47    };
48
49    let parent = Arc::new(lc.listen(laddr).await?);
50    Ok(DTLSListener { parent, config })
51}
52
53/// DTLSListener represents a DTLS listener
54pub struct DTLSListener {
55    parent: Arc<dyn Listener + Send + Sync>,
56    config: Config,
57}
58
59impl DTLSListener {
60    ///  creates a DTLS listener which accepts connections from an inner Listener.
61    pub fn new(parent: Arc<dyn Listener + Send + Sync>, config: Config) -> Result<Self> {
62        validate_config(false, &config)?;
63
64        Ok(DTLSListener { parent, config })
65    }
66}
67
68type UtilResult<T> = std::result::Result<T, util::Error>;
69
70#[async_trait]
71impl Listener for DTLSListener {
72    /// Accept waits for and returns the next connection to the listener.
73    /// You have to either close or read on all connection that are created.
74    /// Connection handshake will timeout using ConnectContextMaker in the Config.
75    /// If you want to specify the timeout duration, set ConnectContextMaker.
76    async fn accept(&self) -> UtilResult<(Arc<dyn Conn + Send + Sync>, SocketAddr)> {
77        let (conn, raddr) = self.parent.accept().await?;
78        let dtls_conn = DTLSConn::new(conn, self.config.clone(), false, None)
79            .await
80            .map_err(util::Error::from_std)?;
81        Ok((Arc::new(dtls_conn), raddr))
82    }
83
84    /// Close closes the listener.
85    /// Any blocked Accept operations will be unblocked and return errors.
86    /// Already Accepted connections are not closed.
87    async fn close(&self) -> UtilResult<()> {
88        self.parent.close().await
89    }
90
91    /// Addr returns the listener's network address.
92    async fn addr(&self) -> UtilResult<SocketAddr> {
93        self.parent.addr().await
94    }
95}
webrtc_dtls/listener.rs

webrtc_dtls/
listener.rs
