use anyhow::{bail, Context, Result}; use clap::Args; use futures_util::{SinkExt, StreamExt}; use serde::{Deserialize, Serialize}; use std::time::Duration; use tokio::{ io::{AsyncReadExt, AsyncWriteExt}, net::TcpStream, time::timeout, }; use tokio_tungstenite::{ client_async_tls_with_config, connect_async_with_config, tungstenite::{client::IntoClientRequest, http::HeaderValue, Message}, MaybeTlsStream, WebSocketStream, }; use url::Url; pub mod transport; pub type Ws = WebSocketStream>; pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(10); pub const IO_TIMEOUT: Duration = Duration::from_secs(30); pub const DEFAULT_RELAY: &str = "wss://ttstd.com/ads"; #[derive(Args, Clone, Debug)] pub struct NetworkArgs { /// Relay base URL; an optional reverse-proxy path prefix is supported #[arg(long, default_value = DEFAULT_RELAY)] pub server: String, /// Optional origin host:port override; TLS still verifies the relay URL hostname #[arg(long, env = "ADS_CONNECT_ADDRESS")] pub connect_address: Option, /// Allow unencrypted ws:// for isolated development only #[arg(long, default_value_t = false)] pub allow_insecure: bool, } impl NetworkArgs { pub fn url(&self, path: &str, params: &[(&str, &str)]) -> Result { let mut url = Url::parse(&self.server).context("invalid relay URL")?; match url.scheme() { "wss" => {} "ws" if self.allow_insecure => {} _ => bail!("use wss://; ws:// requires --allow-insecure for development"), } if !url.username().is_empty() || url.password().is_some() || url.query().is_some() || url.fragment().is_some() { bail!("relay URL must not contain credentials, query, or fragment"); } let endpoint = format!( "{}/{}", url.path().trim_end_matches('/'), path.trim_start_matches('/') ); url.set_path(&endpoint); url.query_pairs_mut().extend_pairs(params.iter().copied()); Ok(url) } } pub fn valid_device_id(id: &str) -> bool { !id.is_empty() && id.len() <= 128 && id .bytes() .all(|c| c.is_ascii_alphanumeric() || b"-_.".contains(&c)) } pub fn validate_token(token: &str) -> Result<()> { if token.len() < 32 { bail!("token must be at least 32 characters"); } HeaderValue::from_str(&format!("Bearer {token}")).context("invalid token characters")?; Ok(()) } pub async fn dial(url: Url, token: &str, connect_address: Option<&str>) -> Result { // WSS needs an explicit provider; relying on transitive feature defaults // leaves pure WebSocket builds without one and panics at the first TLS dial. static TLS_PROVIDER: std::sync::Once = std::sync::Once::new(); TLS_PROVIDER.call_once(|| { let _ = rustls::crypto::ring::default_provider().install_default(); }); let mut request = url.as_str().into_client_request()?; request.headers_mut().insert( "Authorization", HeaderValue::from_str(&format!("Bearer {token}"))?, ); // Do not include the URL in errors: session and lease tickets are secrets. let config = tokio_tungstenite::tungstenite::protocol::WebSocketConfig::default() .max_message_size(Some(128 * 1024)) .max_frame_size(Some(128 * 1024)); let handshake = async { if let Some(address) = connect_address { let tcp = TcpStream::connect(address).await?; tcp.set_nodelay(true)?; client_async_tls_with_config(request, tcp, Some(config), None).await } else { connect_async_with_config(request, Some(config), true).await } }; let result = timeout(CONNECT_TIMEOUT, handshake) .await .context("relay handshake timed out")?; match result { Ok((socket, _)) => Ok(socket), Err(tokio_tungstenite::tungstenite::Error::Http(response)) => { bail!("relay rejected request: HTTP {}", response.status()) } Err(_) => bail!("relay connection failed (check address, TLS certificate and network)"), } } #[derive(Clone, Deserialize, Serialize)] pub struct Control { #[serde(rename = "type")] pub kind: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub device: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub lease: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub session: Option, #[serde(default)] pub protocol: u8, #[serde(default)] pub signal_key: Option, #[serde(default)] pub ice_servers: Vec, #[serde(default)] pub p2p_timeout_ms: u64, #[serde(default)] pub public_only: bool, #[serde(default)] pub routes: Vec, #[serde(default)] pub sdp: Option, #[serde(default)] pub node: Option, } pub async fn next_control(ws: &mut Ws) -> Result { loop { match ws.next().await.context("control connection closed")?? { Message::Text(text) => { if text.len() > 128 * 1024 { bail!("control message too large"); } return Ok(serde_json::from_str(&text)?); } Message::Ping(data) => ws.send(Message::Pong(data)).await?, Message::Pong(_) => {} Message::Close(_) => bail!("control connection closed"), _ => bail!("unexpected control message"), } } } /// Binary-only relay. Bounded chunks and awaited writes provide backpressure. /// A websocket close terminates both directions; TCP half-close is not preserved. pub async fn relay(tcp: TcpStream, ws: Ws) -> Result<()> { tcp.set_nodelay(true)?; let (mut reader, mut writer) = tcp.into_split(); let (mut sink, mut stream) = ws.split(); let to_ws = async { let mut buffer = vec![0; 64 * 1024]; loop { let size = reader.read(&mut buffer).await?; if size == 0 { return Ok::<(), anyhow::Error>(()); } timeout( IO_TIMEOUT, sink.send(Message::Binary(buffer[..size].to_vec().into())), ) .await??; } }; let to_tcp = async { while let Some(message) = stream.next().await { match message? { Message::Binary(data) => { if data.len() > 128 * 1024 { bail!("data message too large"); } timeout(IO_TIMEOUT, writer.write_all(&data)).await??; } Message::Close(_) => return Ok::<(), anyhow::Error>(()), Message::Ping(_) | Message::Pong(_) => {} _ => bail!("unexpected text on binary tunnel"), } } Ok(()) }; // Closing either side tears down this ADB transport; reconnect creates a new one. tokio::select! { result = to_ws => result, result = to_tcp => result } } pub async fn tcp_connect(address: &str) -> Result { Ok(timeout(CONNECT_TIMEOUT, TcpStream::connect(address)) .await .context("TCP connect timed out")??) } pub async fn adb_devices(server: &str) -> Result { timeout(Duration::from_secs(5), async { let mut stream = TcpStream::connect(server) .await .context("cannot connect to Agent host ADB server")?; adb_request(&mut stream, "host:devices-l").await?; let mut size = [0; 4]; stream.read_exact(&mut size).await?; let size = usize::from_str_radix(std::str::from_utf8(&size)?, 16)?; let mut data = vec![0; size]; stream.read_exact(&mut data).await?; Ok::<_, anyhow::Error>(String::from_utf8(data)?) }) .await .context("ADB discovery timed out")? } async fn adb_request(stream: &mut TcpStream, service: &str) -> Result<()> { if service.len() > 65535 { bail!("ADB service name too long"); } stream .write_all(format!("{:04x}{service}", service.len()).as_bytes()) .await?; let mut status = [0; 4]; stream.read_exact(&mut status).await?; match &status { b"OKAY" => Ok(()), b"FAIL" => { let mut size = [0; 4]; stream.read_exact(&mut size).await?; let size = usize::from_str_radix(std::str::from_utf8(&size)?, 16)?; let mut error = vec![0; size]; stream.read_exact(&mut error).await?; bail!("remote ADB: {}", String::from_utf8_lossy(&error)) } _ => bail!("invalid ADB smart socket reply"), } } /// Requires TCP adbd on the phone, even when selecting a USB transport. pub async fn adb_tcp_connect(server: &str, serial: &str, port: u16) -> Result { let mut stream = tcp_connect(server).await?; timeout(CONNECT_TIMEOUT, async { adb_request(&mut stream, &format!("host:transport:{serial}")).await?; adb_request(&mut stream, &format!("tcp:{port}")).await }) .await .context("ADB service handshake timed out")??; Ok(stream) } pub fn init_logging() { tracing_subscriber::fmt() .with_env_filter( tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()), ) .with_target(false) .init(); } #[cfg(test)] mod tests { use super::*; #[test] fn rejects_unsafe_configuration() { let network = NetworkArgs { server: "ws://example.com".into(), connect_address: None, allow_insecure: false, }; assert!(network.url("/v1/agent", &[]).is_err()); assert!(validate_token("short").is_err()); assert!(!valid_device_id("bad/device")); assert!(valid_device_id("home-phone_1")); } #[test] fn relay_prefix_and_query_parameters_are_preserved() { for base in ["wss://ttstd.com/ads", "wss://ttstd.com/ads/"] { let network = NetworkArgs { server: base.into(), connect_address: None, allow_insecure: false, }; let url = network .url( "/v1/connect", &[("device", "home-phone"), ("lease", "secret-ticket")], ) .unwrap(); assert_eq!(url.path(), "/ads/v1/connect"); assert_eq!(url.query(), Some("device=home-phone&lease=secret-ticket")); } assert_eq!(DEFAULT_RELAY, "wss://ttstd.com/ads"); } #[tokio::test] async fn discovers_adb_devices_with_length_framing() { let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let address = listener.local_addr().unwrap().to_string(); let peer = tokio::spawn(async move { let (mut socket, _) = listener.accept().await.unwrap(); let mut size = [0; 4]; socket.read_exact(&mut size).await.unwrap(); let count = usize::from_str_radix(std::str::from_utf8(&size).unwrap(), 16).unwrap(); let mut service = vec![0; count]; socket.read_exact(&mut service).await.unwrap(); assert_eq!(service, b"host:devices-l"); let body = "192.168.1.2:5555\tdevice model:Phone\nUSB123\tunauthorized\n"; let reply = format!("OKAY{:04x}{}", body.len(), body); for chunk in reply.as_bytes().chunks(3) { socket.write_all(chunk).await.unwrap(); } }); let list = adb_devices(&address).await.unwrap(); assert!(list.contains("model:Phone")); assert!(list.contains("unauthorized")); peer.await.unwrap(); } #[tokio::test] async fn tls_failure_is_reported_without_a_provider_panic() { let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let address = listener.local_addr().unwrap().to_string(); let peer = tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); sock.write_all(b"not a TLS record").await.unwrap(); }); let result = dial( Url::parse("wss://relay.invalid/v1/agent").unwrap(), "test-token-at-least-thirty-two-characters", Some(&address), ) .await; assert!(result.is_err()); peer.await.unwrap(); } #[tokio::test] async fn adb_handshake_selects_transport_and_phone_port() { let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let address = listener.local_addr().unwrap().to_string(); let task = tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); for expected in ["host:transport:test", "tcp:5555"] { let mut size = [0; 4]; sock.read_exact(&mut size).await.unwrap(); let size = usize::from_str_radix(std::str::from_utf8(&size).unwrap(), 16).unwrap(); let mut payload = vec![0; size]; sock.read_exact(&mut payload).await.unwrap(); assert_eq!(payload, expected.as_bytes()); sock.write_all(b"OK").await.unwrap(); sock.write_all(b"AY").await.unwrap(); } sock.write_all(b"raw-adbd").await.unwrap(); }); let mut stream = adb_tcp_connect(&address, "test", 5555).await.unwrap(); let mut data = [0; 8]; stream.read_exact(&mut data).await.unwrap(); assert_eq!(&data, b"raw-adbd"); task.await.unwrap(); } }