1 use super::*;
2 
3 use crate::agent::agent_config::AgentConfig;
4 use crate::agent::agent_vnet_test::{connect_with_vnet, on_connected};
5 use crate::agent::Agent;
6 use crate::error::Error;
7 use crate::url::{ProtoType, SchemeType, Url};
8 
9 use std::result::Result;
10 use std::time::Duration;
11 use tokio::net::UdpSocket;
12 use turn::auth::AuthHandler;
13 
14 pub(crate) struct OptimisticAuthHandler;
15 
16 impl AuthHandler for OptimisticAuthHandler {
17     fn auth_handle(
18         &self,
19         _username: &str,
20         _realm: &str,
21         _src_addr: SocketAddr,
22     ) -> Result<Vec<u8>, turn::Error> {
23         Ok(turn::auth::generate_auth_key(
24             "username",
25             "webrtc.rs",
26             "password",
27         ))
28     }
29 }
30 
31 //use std::io::Write;
32 
33 #[tokio::test]
34 async fn test_relay_only_connection() -> Result<(), Error> {
35     /*env_logger::Builder::new()
36     .format(|buf, record| {
37         writeln!(
38             buf,
39             "{}:{} [{}] {} - {}",
40             record.file().unwrap_or("unknown"),
41             record.line().unwrap_or(0),
42             record.level(),
43             chrono::Local::now().format("%H:%M:%S.%6f"),
44             record.args()
45         )
46     })
47     .filter(None, log::LevelFilter::Trace)
48     .init();*/
49 
50     let server_listener = Arc::new(UdpSocket::bind("127.0.0.1:0").await?);
51     let server_port = server_listener.local_addr()?.port();
52 
53     let server = turn::server::Server::new(turn::server::config::ServerConfig {
54         realm: "webrtc.rs".to_owned(),
55         auth_handler: Arc::new(OptimisticAuthHandler {}),
56         conn_configs: vec![turn::server::config::ConnConfig {
57             conn: server_listener,
58             relay_addr_generator: Box::new(turn::relay::relay_none::RelayAddressGeneratorNone {
59                 address: "127.0.0.1".to_owned(),
60                 net: Arc::new(util::vnet::net::Net::new(None)),
61             }),
62         }],
63         channel_bind_timeout: Duration::from_secs(0),
64     })
65     .await?;
66 
67     let cfg0 = AgentConfig {
68         network_types: supported_network_types(),
69         urls: vec![Url {
70             scheme: SchemeType::Turn,
71             host: "127.0.0.1".to_owned(),
72             username: "username".to_owned(),
73             password: "password".to_owned(),
74             port: server_port,
75             proto: ProtoType::Udp,
76         }],
77         candidate_types: vec![CandidateType::Relay],
78         ..Default::default()
79     };
80 
81     let a_agent = Arc::new(Agent::new(cfg0).await?);
82     let (a_notifier, mut a_connected) = on_connected();
83     a_agent.on_connection_state_change(a_notifier);
84 
85     let cfg1 = AgentConfig {
86         network_types: supported_network_types(),
87         urls: vec![Url {
88             scheme: SchemeType::Turn,
89             host: "127.0.0.1".to_owned(),
90             username: "username".to_owned(),
91             password: "password".to_owned(),
92             port: server_port,
93             proto: ProtoType::Udp,
94         }],
95         candidate_types: vec![CandidateType::Relay],
96         ..Default::default()
97     };
98 
99     let b_agent = Arc::new(Agent::new(cfg1).await?);
100     let (b_notifier, mut b_connected) = on_connected();
101     b_agent.on_connection_state_change(b_notifier);
102 
103     connect_with_vnet(&a_agent, &b_agent).await?;
104 
105     let _ = a_connected.recv().await;
106     let _ = b_connected.recv().await;
107 
108     a_agent.close().await?;
109     b_agent.close().await?;
110     server.close().await?;
111 
112     Ok(())
113 }
114