rsfu/sfu/
turn.rs

1use std::net::SocketAddr;
2use tokio::net::UdpSocket;
3use tokio::time::Duration;
4use turn::relay::relay_range::RelayAddressGeneratorRanges;
5use turn::server::config::ConnConfig;
6use turn::server::config::ServerConfig;
7use turn::server::Server as TurnServer;
8
9use std::sync::Arc;
10use turn::auth;
11use turn::auth::AuthHandler;
12use turn::auth::LongTermAuthHandler;
13use turn::Error;
14
15use anyhow::Result as AnyhowResult;
16use regex::Regex;
17use std::collections::HashMap;
18use std::net::IpAddr;
19use std::result::Result;
20
21use std::str::FromStr;
22use webrtc_util::vnet::net::*;
23
24use serde::Deserialize;
25
26//use util::vnet::net::
27
28pub const TURN_MIN_PORT: u16 = 32768;
29pub const TURN_MAX_PORT: u16 = 46883;
30
31pub const SFU_MIN_PORT: u16 = 46884;
32pub const SFU_MAX_PORT: u16 = 60999;
33#[derive(Clone, Default, Deserialize)]
34pub(super) struct TurnAuth {
35    #[serde(rename = "credentials")]
36    #[allow(dead_code)]
37    credentials: String,
38    secret: Option<String>,
39}
40#[derive(Clone, Default, Deserialize)]
41pub(super) struct TurnConfig {
42    #[serde(rename = "enabled")]
43    pub(super) enabled: bool,
44    #[serde(rename = "realm")]
45    realm: String,
46    #[serde(rename = "address")]
47    address: String,
48    #[allow(dead_code)]
49    cert: Option<String>,
50    #[allow(dead_code)]
51    key: Option<String>,
52    auth: TurnAuth,
53    pub(super) port_range: Option<Vec<u16>>,
54}
55
56struct CustomAuthHandler {
57    users_map: HashMap<String, Vec<u8>>,
58}
59impl CustomAuthHandler {
60    fn new(user_map: HashMap<String, Vec<u8>>) -> Self {
61        Self {
62            users_map: user_map,
63        }
64    }
65}
66impl AuthHandler for CustomAuthHandler {
67    fn auth_handle(
68        &self,
69        username: &str,
70        realm: &str,
71        _src_addr: SocketAddr,
72    ) -> Result<Vec<u8>, Error> {
73        if let Some(val) = self.users_map.get(&username.to_string()) {
74            return Ok(val.clone());
75        }
76        log::trace!("realm val: {}", realm);
77
78        Err(Error::ErrNilConn)
79    }
80}
81
82pub(super) async fn init_turn_server(
83    conf: TurnConfig,
84    auth: Option<Arc<dyn AuthHandler + Send + Sync>>,
85) -> AnyhowResult<TurnServer> {
86    let conn = Arc::new(UdpSocket::bind(conf.address.clone()).await?);
87    println!("listening {}...", conn.local_addr()?);
88
89    let mut new_auth: Option<Arc<dyn AuthHandler + Send + Sync>> = auth;
90
91    if new_auth.is_none() {
92        if let Some(secret) = conf.auth.secret {
93            new_auth = Some(Arc::new(LongTermAuthHandler::new(secret)));
94        } else {
95            let mut users_map: HashMap<String, Vec<u8>> = HashMap::new();
96            let re = Regex::new(r"(\w+)=(\w+)").unwrap();
97
98            for caps in re.captures_iter(conf.realm.clone().as_str()) {
99                let username = caps.get(1).unwrap().as_str();
100                let username_string = username.to_string();
101                let password = caps.get(2).unwrap().as_str();
102                users_map.insert(
103                    username_string,
104                    auth::generate_auth_key(username, conf.realm.clone().as_str(), password),
105                );
106            }
107
108            if users_map.is_empty() {
109                log::error!("no turn auth provided.");
110            }
111
112            new_auth = Some(Arc::new(CustomAuthHandler::new(users_map)))
113        }
114    }
115
116    let mut min_port: u16 = TURN_MIN_PORT;
117    let mut max_port: u16 = TURN_MAX_PORT;
118
119    if let Some(port_range) = conf.port_range {
120        if port_range.len() == 2 {
121            min_port = port_range[0];
122            max_port = port_range[1];
123        }
124    }
125
126    let addr: Vec<&str> = conf.address.split(':').collect();
127
128    let conn_configs = vec![ConnConfig {
129        conn,
130        relay_addr_generator: Box::new(RelayAddressGeneratorRanges {
131            min_port,
132            max_port,
133            max_retries: 1,
134            relay_address: IpAddr::from_str(addr[0])?,
135            address: "0.0.0.0".to_owned(),
136            net: Arc::new(Net::new(Some(NetConfig::default()))),
137        }),
138    }];
139
140    let turn_server = TurnServer::new(ServerConfig {
141        conn_configs,
142        realm: conf.realm,
143        auth_handler: new_auth.unwrap(),
144        channel_bind_timeout: Duration::from_secs(5),
145    })
146    .await?;
147    Ok(turn_server)
148}
rsfu/sfu/turn.rs

rsfu/sfu/
turn.rs
