Implement authenticated public relay and Rust device daemons

This commit is contained in:
tongtong committed 2026-11-12 12:33:39 +08:00
1 parent f96c1aa109
commit e1c152a657
29 files changed
+3244 -39

No files matched your search

+166
View File
@@ -0,0 +1,166 @@
use ads_core::{
dial, init_logging, next_control, relay, valid_device_id, validate_token, NetworkArgs,
};
use anyhow::{bail, Context, Result};
use clap::Parser;
use std::{net::SocketAddr, path::PathBuf, sync::Arc, time::Duration};
use tokio::{
net::TcpListener,
process::Command,
sync::watch,
task::JoinSet,
time::{sleep, timeout},
};
use tracing::{info, warn};
#[derive(Parser)]
#[command(
version,
about = "Local ADS daemon: expose a remote phone as a local adb connect endpoint"
)]
struct Args {
#[command(flatten)]
network: NetworkArgs,
#[arg(long, env = "ADS_CLIENT_TOKEN", hide_env_values = true)]
token: String,
#[arg(long)]
device: String,
/// Local endpoint; loopback addresses only
#[arg(long, default_value = "127.0.0.1:15555")]
listen: SocketAddr,
#[arg(long, default_value = "adb")]
adb: PathBuf,
/// Do not periodically invoke local adb connect (useful for manual control/tests)
#[arg(long)]
no_auto_connect: bool,
}
async fn lease_once(args: &Args, state: &watch::Sender<Option<String>>) -> Result<()> {
let mut ws = dial(
args.network.url("/v1/lease", &[("device", &args.device)])?,
&args.token,
)
.await?;
let response = next_control(&mut ws).await?;
if response.kind != "leased" {
bail!("expected leased response");
}
let id = response.lease.context("missing lease ticket")?;
state.send_replace(Some(id));
info!(device = %args.device, endpoint = %args.listen, "device leased; local tunnel ready");
loop {
next_control(&mut ws).await?;
}
}
async fn maintain_lease(args: Arc<Args>, state: watch::Sender<Option<String>>) {
let mut delay = 1;
loop {
let started = std::time::Instant::now();
if let Err(error) = lease_once(&args, &state).await {
warn!(%error, "lease unavailable; reconnecting");
}
state.send_replace(None);
if started.elapsed() > Duration::from_secs(30) {
delay = 1;
}
sleep(Duration::from_secs(delay)).await;
delay = (delay * 2).min(30);
}
}
async fn adb_command(args: &Args, action: &str) -> Result<()> {
let output = timeout(
Duration::from_secs(8),
Command::new(&args.adb)
.env_remove("ADB_SERVER_SOCKET")
.env_remove("ANDROID_ADB_SERVER_ADDRESS")
.env_remove("ANDROID_ADB_SERVER_PORT")
.arg(action)
.arg(args.listen.to_string())
.kill_on_drop(true)
.output(),
)
.await
.context("adb command timed out")??;
if !output.status.success() {
bail!(
"adb command failed: {}",
String::from_utf8_lossy(&output.stderr).trim()
);
}
// adb can report a connection failure with exit code 0; retain its text.
let message = String::from_utf8_lossy(&output.stdout);
info!(output = %message.trim(), "local adb");
Ok(())
}
async fn maintain_adb(args: Arc<Args>, state: watch::Receiver<Option<String>>) {
loop {
if state.borrow().is_some() {
if let Err(error) = adb_command(&args, "connect").await {
warn!(%error, "local adb connect failed");
}
}
sleep(Duration::from_secs(5)).await;
}
}
async fn accept_connections(
args: Arc<Args>,
listener: TcpListener,
state: watch::Receiver<Option<String>>,
) -> Result<()> {
let mut tasks = JoinSet::new();
loop {
tokio::select! {
accepted = listener.accept() => {
let (tcp, _) = accepted?;
let lease = state.borrow().clone();
let Some(lease) = lease else { drop(tcp); continue; };
if tasks.len() >= 32 { drop(tcp); warn!("local stream limit reached"); continue; }
let args = args.clone();
tasks.spawn(async move {
let result = async {
let url = args.network.url("/v1/connect", &[("device", &args.device), ("lease", &lease)])?;
let ws = dial(url, &args.token).await?;
relay(tcp, ws).await
}.await;
if let Err(error) = result { warn!(%error, "local device stream ended"); }
});
},
_ = tasks.join_next(), if !tasks.is_empty() => {},
}
}
}
#[tokio::main]
async fn main() -> Result<()> {
init_logging();
let args = Arc::new(Args::parse());
validate_token(&args.token)?;
if !valid_device_id(&args.device) {
bail!("invalid device ID");
}
if !args.listen.ip().is_loopback() || args.listen.port() == 0 {
bail!("--listen must use a loopback address and a nonzero port");
}
args.network.url("/v1/lease", &[])?;
let listener = TcpListener::bind(args.listen)
.await
.context("cannot bind local ADB endpoint")?;
let (sender, receiver) = watch::channel(None);
info!(endpoint = %args.listen, "listening; local adb will show this address after connection");
// Dropping these futures on shutdown closes control and data connections.
tokio::select! {
_ = maintain_lease(args.clone(), sender) => {},
_ = maintain_adb(args.clone(), receiver.clone()), if !args.no_auto_connect => {},
result = accept_connections(args.clone(), listener, receiver) => { result?; },
result = tokio::signal::ctrl_c() => { result?; },
}
if !args.no_auto_connect {
let _ = adb_command(&args, "disconnect").await;
}
info!("client stopping");
Ok(())
}