Files
AndroidDeviceStreaming/crates/ads-core/src/lib.rs
T

371 lines
14 KiB
Rust

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<MaybeTlsStream<TcpStream>>;
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<String>,
/// 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<Url> {
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<Ws> {
// 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<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lease: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
#[serde(default)]
pub protocol: u8,
#[serde(default)]
pub signal_key: Option<String>,
#[serde(default)]
pub ice_servers: Vec<String>,
#[serde(default)]
pub p2p_timeout_ms: u64,
#[serde(default)]
pub public_only: bool,
#[serde(default)]
pub routes: Vec<transport::Route>,
#[serde(default)]
pub sdp: Option<String>,
#[serde(default)]
pub node: Option<String>,
}
pub async fn next_control(ws: &mut Ws) -> Result<Control> {
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<TcpStream> {
Ok(timeout(CONNECT_TIMEOUT, TcpStream::connect(address))
.await
.context("TCP connect timed out")??)
}
pub async fn adb_devices(server: &str) -> Result<String> {
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<TcpStream> {
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();
}
}