1 use super::config::*;
2 use super::*;
3 use crate::auth::generate_auth_key;
4 use crate::client::*;
5 use crate::error::*;
6 use crate::relay::relay_static::*;
7
8 use crate::relay::relay_none::RelayAddressGeneratorNone;
9 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
10 use std::str::FromStr;
11 use tokio::net::UdpSocket;
12 use tokio::sync::mpsc;
13 use util::{vnet::router::Nic, vnet::*};
14
15 struct TestAuthHandler {
16 cred_map: HashMap<String, Vec<u8>>,
17 }
18
19 impl TestAuthHandler {
new() -> Self20 fn new() -> Self {
21 let mut cred_map = HashMap::new();
22 cred_map.insert(
23 "user".to_owned(),
24 generate_auth_key("user", "webrtc.rs", "pass"),
25 );
26
27 TestAuthHandler { cred_map }
28 }
29 }
30
31 impl AuthHandler for TestAuthHandler {
auth_handle(&self, username: &str, _realm: &str, _src_addr: SocketAddr) -> Result<Vec<u8>>32 fn auth_handle(&self, username: &str, _realm: &str, _src_addr: SocketAddr) -> Result<Vec<u8>> {
33 if let Some(pw) = self.cred_map.get(username) {
34 Ok(pw.to_vec())
35 } else {
36 Err(Error::ErrFakeErr)
37 }
38 }
39 }
40
41 #[tokio::test]
test_server_simple() -> Result<()>42 async fn test_server_simple() -> Result<()> {
43 // here, it should use static port, like "0.0.0.0:3478",
44 // but, due to different test environment, let's fake it by using "0.0.0.0:0"
45 // to auto assign a "static" port
46 let conn = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
47 let server_port = conn.local_addr()?.port();
48
49 let server = Server::new(ServerConfig {
50 conn_configs: vec![ConnConfig {
51 conn,
52 relay_addr_generator: Box::new(RelayAddressGeneratorStatic {
53 relay_address: IpAddr::from_str("127.0.0.1")?,
54 address: "0.0.0.0".to_owned(),
55 net: Arc::new(net::Net::new(None)),
56 }),
57 }],
58 realm: "webrtc.rs".to_owned(),
59 auth_handler: Arc::new(TestAuthHandler::new()),
60 channel_bind_timeout: Duration::from_secs(0),
61 alloc_close_notify: None,
62 })
63 .await?;
64
65 assert_eq!(
66 DEFAULT_LIFETIME, server.channel_bind_timeout,
67 "should match"
68 );
69
70 let conn = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
71
72 let client = Client::new(ClientConfig {
73 stun_serv_addr: String::new(),
74 turn_serv_addr: String::new(),
75 username: String::new(),
76 password: String::new(),
77 realm: String::new(),
78 software: String::new(),
79 rto_in_ms: 0,
80 conn,
81 vnet: None,
82 })
83 .await?;
84
85 client.listen().await?;
86
87 client
88 .send_binding_request_to(format!("127.0.0.1:{server_port}").as_str())
89 .await?;
90
91 client.close().await?;
92 server.close().await?;
93
94 Ok(())
95 }
96
97 struct VNet {
98 wan: Arc<Mutex<router::Router>>,
99 net0: Arc<net::Net>,
100 net1: Arc<net::Net>,
101 netl0: Arc<net::Net>,
102 server: Server,
103 }
104
build_vnet() -> Result<VNet>105 async fn build_vnet() -> Result<VNet> {
106 // WAN
107 let wan = Arc::new(Mutex::new(router::Router::new(router::RouterConfig {
108 cidr: "0.0.0.0/0".to_owned(),
109 ..Default::default()
110 })?));
111
112 let net0 = Arc::new(net::Net::new(Some(net::NetConfig {
113 static_ip: "1.2.3.4".to_owned(), // will be assigned to eth0
114 ..Default::default()
115 })));
116
117 let net1 = Arc::new(net::Net::new(Some(net::NetConfig {
118 static_ip: "1.2.3.5".to_owned(), // will be assigned to eth0
119 ..Default::default()
120 })));
121
122 {
123 let nic0 = net0.get_nic()?;
124 let nic1 = net1.get_nic()?;
125
126 {
127 let mut w = wan.lock().await;
128 w.add_net(Arc::clone(&nic0)).await?;
129 w.add_net(Arc::clone(&nic1)).await?;
130 }
131
132 let n0 = nic0.lock().await;
133 n0.set_router(Arc::clone(&wan)).await?;
134
135 let n1 = nic1.lock().await;
136 n1.set_router(Arc::clone(&wan)).await?;
137 }
138
139 // LAN
140 let lan = Arc::new(Mutex::new(router::Router::new(router::RouterConfig {
141 static_ip: "5.6.7.8".to_owned(), // this router's external IP on eth0
142 cidr: "192.168.0.0/24".to_owned(),
143 nat_type: Some(nat::NatType {
144 mapping_behavior: nat::EndpointDependencyType::EndpointIndependent,
145 filtering_behavior: nat::EndpointDependencyType::EndpointIndependent,
146 ..Default::default()
147 }),
148 ..Default::default()
149 })?));
150
151 let netl0 = Arc::new(net::Net::new(Some(net::NetConfig::default())));
152
153 {
154 let nic = netl0.get_nic()?;
155
156 {
157 let mut l = lan.lock().await;
158 l.add_net(Arc::clone(&nic)).await?;
159 }
160
161 let n = nic.lock().await;
162 n.set_router(Arc::clone(&lan)).await?;
163 }
164
165 {
166 {
167 let mut w = wan.lock().await;
168 w.add_router(Arc::clone(&lan)).await?;
169 }
170
171 {
172 let l = lan.lock().await;
173 l.set_router(Arc::clone(&wan)).await?;
174 }
175 }
176
177 {
178 let mut w = wan.lock().await;
179 w.start().await?;
180 }
181
182 // start server...
183 let conn = net0.bind(SocketAddr::from_str("0.0.0.0:3478")?).await?;
184
185 let server = Server::new(ServerConfig {
186 conn_configs: vec![ConnConfig {
187 conn,
188 relay_addr_generator: Box::new(RelayAddressGeneratorNone {
189 address: "1.2.3.4".to_owned(),
190 net: Arc::clone(&net0),
191 }),
192 }],
193 realm: "webrtc.rs".to_owned(),
194 auth_handler: Arc::new(TestAuthHandler::new()),
195 channel_bind_timeout: Duration::from_secs(0),
196 alloc_close_notify: None,
197 })
198 .await?;
199
200 // register host names
201 {
202 let mut w = wan.lock().await;
203 w.add_host("stun.webrtc.rs".to_owned(), "1.2.3.4".to_owned())
204 .await?;
205 w.add_host("turn.webrtc.rs".to_owned(), "1.2.3.4".to_owned())
206 .await?;
207 w.add_host("echo.webrtc.rs".to_owned(), "1.2.3.5".to_owned())
208 .await?;
209 }
210
211 Ok(VNet {
212 wan,
213 net0,
214 net1,
215 netl0,
216 server,
217 })
218 }
219
220 #[tokio::test]
test_server_vnet_send_binding_request() -> Result<()>221 async fn test_server_vnet_send_binding_request() -> Result<()> {
222 let v = build_vnet().await?;
223
224 let lconn = v.netl0.bind(SocketAddr::from_str("0.0.0.0:0")?).await?;
225 log::debug!("creating a client.");
226 let client = Client::new(ClientConfig {
227 stun_serv_addr: "1.2.3.4:3478".to_owned(),
228 turn_serv_addr: String::new(),
229 username: String::new(),
230 password: String::new(),
231 realm: String::new(),
232 software: String::new(),
233 rto_in_ms: 0,
234 conn: lconn,
235 vnet: Some(Arc::clone(&v.netl0)),
236 })
237 .await?;
238
239 client.listen().await?;
240
241 log::debug!("sending a binding request.");
242 let refl_addr = client.send_binding_request().await?;
243 log::debug!("mapped-address: {}", refl_addr);
244
245 // The mapped-address should have IP address that was assigned
246 // to the LAN router.
247 assert_eq!(
248 refl_addr.ip().to_string(),
249 Ipv4Addr::new(5, 6, 7, 8).to_string(),
250 "should match",
251 );
252
253 client.close().await?;
254 Ok(())
255 }
256
257 #[tokio::test]
test_server_vnet_echo_via_relay() -> Result<()>258 async fn test_server_vnet_echo_via_relay() -> Result<()> {
259 let v = build_vnet().await?;
260
261 let lconn = v.netl0.bind(SocketAddr::from_str("0.0.0.0:0")?).await?;
262 log::debug!("creating a client.");
263 let client = Client::new(ClientConfig {
264 stun_serv_addr: "stun.webrtc.rs:3478".to_owned(),
265 turn_serv_addr: "turn.webrtc.rs:3478".to_owned(),
266 username: "user".to_owned(),
267 password: "pass".to_owned(),
268 realm: String::new(),
269 software: String::new(),
270 rto_in_ms: 0,
271 conn: lconn,
272 vnet: Some(Arc::clone(&v.netl0)),
273 })
274 .await?;
275
276 client.listen().await?;
277
278 log::debug!("sending a binding request.");
279 let conn = client.allocate().await?;
280 let local_addr = conn.local_addr()?;
281
282 log::debug!("laddr: {}", conn.local_addr()?);
283
284 let echo_conn = v.net1.bind(SocketAddr::from_str("1.2.3.5:5678")?).await?;
285 let echo_addr = echo_conn.local_addr()?;
286
287 let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
288
289 tokio::spawn(async move {
290 let mut buf = vec![0u8; 1500];
291 let mut n;
292 let mut from;
293 loop {
294 tokio::select! {
295 _ = done_rx.recv() => break,
296 result = echo_conn.recv_from(&mut buf) => {
297 match result {
298 Ok((s, addr)) => {
299 n = s;
300 from = addr;
301 }
302 Err(_) => break,
303 }
304 }
305 }
306
307 // verify the message was received from the relay address
308 assert_eq!(local_addr.to_string(), from.to_string(), "should match");
309 assert_eq!(b"Hello", &buf[..n], "should match");
310
311 // echo the data
312 let _ = echo_conn.send_to(&buf[..n], from).await;
313 }
314 });
315
316 let mut buf = vec![0u8; 1500];
317
318 for _ in 0..10 {
319 log::debug!("sending \"Hello\"..");
320 conn.send_to(b"Hello", echo_addr).await?;
321
322 let (_, from) = conn.recv_from(&mut buf).await?;
323
324 // verify the message was received from the relay address
325 assert_eq!(echo_addr.to_string(), from.to_string(), "should match");
326
327 tokio::time::sleep(Duration::from_millis(100)).await;
328 }
329
330 tokio::time::sleep(Duration::from_millis(100)).await;
331
332 client.close().await?;
333 drop(done_tx);
334
335 Ok(())
336 }
337