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