Implement authenticated public relay and Rust device daemons
This commit is contained in:
1 parent
f96c1aa109
commit
e1c152a657
29 files changed
+3244
-39
No files matched your search
@@ -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(())
|
||||
}
|
||||
Reference in new issue
Block a user