use super::{Sudo, VersionProbe};
use crate::target::RemoteTarget;
use crate::{Error, Result};
use std::path::Path;
use std::process::Stdio;
use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
use tokio::process::{Child, ChildStdin, ChildStdout, Command};
pub const DEFAULT_REMOTE_PATH: &str = "~/.cargo/bin/cp2";
const SSH_COMMAND_TIMEOUT: std::time::Duration = std::time::Duration::from_mins(2);
#[derive(Default)]
pub struct SshAuth<'a> {
pub(crate) password: Option<&'a str>,
pub(crate) jump_password: Option<&'a str>,
pub(crate) control_path: Option<&'a str>,
}
pub struct SshChild {
pub child: Child,
pub stdin: ChildStdin,
pub stdout: ChildStdout,
}
fn drain_child_stderr(stderr: tokio::process::ChildStderr) {
#[cfg(unix)]
let mut pipe: std::fs::File = match stderr.into_owned_fd() {
Ok(fd) => fd.into(),
Err(_) => return,
};
#[cfg(not(unix))]
let mut pipe: std::fs::File = match stderr.into_owned_handle() {
Ok(handle) => handle.into(),
Err(_) => return,
};
let _ = std::thread::Builder::new()
.name("cp2-ssh-stderr".to_string())
.spawn(move || {
use std::io::{Read, Write};
let mut buf = [0u8; 8192];
let mut sink = std::io::stderr();
loop {
match pipe.read(&mut buf) {
Ok(0) | Err(_) => return,
Ok(n) => {
if sink.write_all(&buf[..n]).is_err() {
return;
}
}
}
}
});
}
fn multiplex_args_with(auth: &SshAuth<'_>) -> Vec<String> {
if cfg!(windows) {
return Vec::new();
}
let path = auth.control_path.map_or_else(
|| {
std::env::temp_dir()
.join("cp2-ssh-%C")
.to_string_lossy()
.replace('\\', "/")
},
str::to_string,
);
let persist = if auth.password.is_some() || auth.jump_password.is_some() {
"86400"
} else {
"60"
};
vec![
"-o".to_string(),
"ControlMaster=auto".to_string(),
"-o".to_string(),
format!("ControlPath={path}"),
"-o".to_string(),
format!("ControlPersist={persist}"),
]
}
fn ssh_command(peer: &RemoteTarget, remote_cmd: &str, auth: &SshAuth<'_>) -> Command {
let mut cmd = Command::new("ssh");
cmd.arg("-p")
.arg(peer.port.to_string())
.arg(format!("{}@{}", peer.user, peer.host))
.args(multiplex_args_with(auth))
.arg(remote_cmd);
cmd
}
impl SshChild {
#[must_use]
pub fn into_parts(
self,
) -> (
Box<dyn AsyncWrite + Unpin + Send>,
Box<dyn AsyncRead + Unpin + Send>,
Child,
) {
(Box::new(self.stdin), Box::new(self.stdout), self.child)
}
}
pub async fn spawn_ssh(
peer: &RemoteTarget,
remote_path: &str,
remote_os: &str,
server_args: &str,
auth: &SshAuth<'_>,
sudo: Sudo,
sudo_password: Option<&str>,
) -> Result<SshChild> {
let remote_cmd = server_invocation(remote_path, remote_os, server_args, sudo);
let mut cmd = ssh_command(peer, &remote_command(remote_os, &remote_cmd), auth);
cmd.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(if cfg!(unix) { Stdio::piped() } else { Stdio::inherit() });
let mut child = cmd.spawn().map_err(Error::Io)?;
if let Some(stderr) = child.stderr.take() {
drain_child_stderr(stderr);
}
if sudo == Sudo::Password {
use tokio::io::AsyncWriteExt;
let mut stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
stdin
.write_all(format!("{}
", sudo_password.unwrap_or_default()).as_bytes())
.await
.map_err(Error::Io)?;
child.stdin = Some(stdin);
}
let stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
let stdout = child
.stdout
.take()
.ok_or_else(|| Error::Other("ssh stdout unavailable".to_string()))?;
crate::platform::fs::enlarge_pipe(&stdin);
crate::platform::fs::enlarge_pipe(&stdout);
Ok(SshChild {
child,
stdin,
stdout,
})
}
fn server_invocation(remote_path: &str, remote_os: &str, server_args: &str, sudo: Sudo) -> String {
let quoted_path = if remote_os == "windows" {
remote_path.to_string()
} else {
shell_quote(remote_path)
};
let base = if server_args.is_empty() {
format!("{quoted_path} --server")
} else {
format!("{quoted_path} --server {server_args}")
};
match sudo {
Sudo::None => base,
Sudo::NonInteractive => format!("sudo -n {base}"),
Sudo::Password => format!("sudo -S {base}"),
}
}
pub(crate) fn preamble_command(remote_path: &str, server_args: &str) -> String {
let quoted = shell_quote(remote_path);
let base = if server_args.is_empty() {
format!("{quoted} --server")
} else {
format!("{quoted} --server {server_args}")
};
format!("uname -s -m 2>/dev/null; printf '\\n{COMPOUND_SEP}\\n'; exec {base}")
}
pub fn spawn_ssh_preamble(
peer: &RemoteTarget,
remote_path: &str,
server_args: &str,
auth: &SshAuth<'_>,
) -> Result<SshChild> {
let remote_cmd = preamble_command(remote_path, server_args);
let mut cmd = ssh_command(peer, &remote_cmd, auth);
cmd.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(if cfg!(unix) { Stdio::piped() } else { Stdio::inherit() });
let mut child = cmd.spawn().map_err(Error::Io)?;
if let Some(stderr) = child.stderr.take() {
drain_child_stderr(stderr);
}
let stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
let stdout = child
.stdout
.take()
.ok_or_else(|| Error::Other("ssh stdout unavailable".to_string()))?;
crate::platform::fs::enlarge_pipe(&stdin);
crate::platform::fs::enlarge_pipe(&stdout);
Ok(SshChild {
child,
stdin,
stdout,
})
}
pub(crate) struct PrefixedReader {
prefix: Vec<u8>,
pos: usize,
inner: Box<dyn AsyncRead + Unpin + Send>,
}
impl PrefixedReader {
fn new(prefix: Vec<u8>, inner: Box<dyn AsyncRead + Unpin + Send>) -> Self {
Self {
prefix,
pos: 0,
inner,
}
}
}
impl AsyncRead for PrefixedReader {
fn poll_read(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
buf: &mut tokio::io::ReadBuf<'_>,
) -> std::task::Poll<std::io::Result<()>> {
if self.pos < self.prefix.len() {
let n = std::cmp::min(buf.remaining(), self.prefix.len() - self.pos);
buf.put_slice(&self.prefix[self.pos..self.pos + n]);
self.pos += n;
return std::task::Poll::Ready(Ok(()));
}
std::pin::Pin::new(&mut self.inner).poll_read(cx, buf)
}
}
pub(crate) async fn read_preamble_platform<R: AsyncRead + Unpin + Send + 'static>(
mut stdout: R,
) -> std::io::Result<Option<(String, String, PrefixedReader)>> {
use tokio::io::AsyncReadExt;
const PREAMBLE_MAX: usize = 64 * 1024;
let mut buf: Vec<u8> = Vec::new();
loop {
if let Some(idx) = find_marker(&buf) {
let head = String::from_utf8_lossy(&buf[..idx]);
let platform = parse_uname(head.trim());
let marker_end = idx + COMPOUND_SEP.len();
let mut tail = marker_end;
while tail < buf.len() && buf[tail] == b'\n' {
tail += 1;
}
let prefix = buf[tail..].to_vec();
return Ok(platform.map(|(os, arch)| {
(os, arch, PrefixedReader::new(prefix, Box::new(stdout)))
}));
}
if buf.len() >= PREAMBLE_MAX {
return Ok(None);
}
let mut chunk = [0u8; 1024];
let n = stdout.read(&mut chunk).await?;
if n == 0 {
return Ok(None);
}
buf.extend_from_slice(&chunk[..n]);
}
}
fn find_marker(buf: &[u8]) -> Option<usize> {
let marker = COMPOUND_SEP.as_bytes();
buf.windows(marker.len()).position(|w| w == marker)
}
pub async fn check_remote_version(
peer: &RemoteTarget,
remote_path: &str,
remote_os: &str,
auth: &SshAuth<'_>,
sudo: Sudo,
sudo_password: Option<&str>,
) -> Result<VersionProbe> {
if sudo == Sudo::None {
let remote_cmd = if remote_os == "windows" {
remote_command(remote_os, &format!("{remote_path} --version"))
} else {
let quoted = shell_quote(remote_path);
format!("test -x {quoted} && {quoted} --version")
};
let output = tokio::time::timeout(
SSH_COMMAND_TIMEOUT,
ssh_command(peer, &remote_cmd, auth)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.output(),
)
.await
.map_err(|_| {
Error::Other("timed out checking the remote cp2 version — the remote may be hung".to_string())
})?
.map_err(Error::Io)?;
if output.status.code() == Some(255) {
return Err(connection_error(peer));
}
let version = output
.status
.success()
.then(|| parse_remote_version(&String::from_utf8_lossy(&output.stdout)))
.flatten();
return Ok(VersionProbe {
version,
sudo_password_required: false,
mode: Sudo::None,
});
}
let quoted = shell_quote(remote_path);
let probe_cmd = format!("test -x {quoted} && sudo -n {quoted} --version");
let (code, stdout, stderr) =
run_version_probe(peer, &probe_cmd, auth, Sudo::NonInteractive, None).await?;
if code == 255 {
return Err(connection_error(peer));
}
if code == 0 {
return Ok(VersionProbe {
version: parse_remote_version(&String::from_utf8_lossy(&stdout)),
sudo_password_required: false,
mode: Sudo::NonInteractive,
});
}
if String::from_utf8_lossy(&stderr)
.to_ascii_lowercase()
.contains("password")
{
let Some(pw) = sudo_password else {
return Ok(VersionProbe {
version: None,
sudo_password_required: true,
mode: Sudo::NonInteractive,
});
};
let probe_cmd = format!("test -x {quoted} && sudo -S {quoted} --version");
let (code, stdout, _) =
run_version_probe(peer, &probe_cmd, auth, Sudo::Password, Some(pw)).await?;
if code == 255 {
return Err(connection_error(peer));
}
if code == 0 {
return Ok(VersionProbe {
version: parse_remote_version(&String::from_utf8_lossy(&stdout)),
sudo_password_required: false,
mode: Sudo::Password,
});
}
return Err(Error::Other(
"the remote sudo password was rejected (sudo -S failed); check --sudo-password / --password"
.to_string(),
));
}
Ok(VersionProbe {
version: None,
sudo_password_required: false,
mode: Sudo::NonInteractive,
})
}
const COMPOUND_SEP: &str = "__CP2_PROBE_SEP__";
fn parse_compound_probe(out: &str) -> (PlatformProbe, Option<(String, Option<String>)>) {
let (head, tail) = out.split_once(COMPOUND_SEP).unwrap_or((out.trim(), ""));
(
parse_uname(head.trim()),
parse_remote_version(tail.trim()),
)
}
pub(crate) type PlatformProbe = Option<(String, String)>;
pub async fn check_remote_platform_and_version(
peer: &RemoteTarget,
remote_path: &str,
auth: &SshAuth<'_>,
sudo: Sudo,
sudo_password: Option<&str>,
) -> Result<(PlatformProbe, VersionProbe)> {
async fn run_compound(
peer: &RemoteTarget,
remote_cmd: &str,
auth: &SshAuth<'_>,
sudo: Sudo,
pw: Option<&str>,
) -> Result<(u32, PlatformProbe, Option<(String, Option<String>)>, Vec<u8>)> {
let (code, stdout, stderr) = run_version_probe(peer, remote_cmd, auth, sudo, pw).await?;
if code == 255 {
return Err(connection_error(peer));
}
let out = String::from_utf8_lossy(&stdout);
let (platform, version) = parse_compound_probe(&out);
Ok((code, platform, version, stderr))
}
let quoted = shell_quote(remote_path);
let plain = format!(
"uname -s -m 2>/dev/null; printf '\\n{COMPOUND_SEP}\\n'; test -x {quoted} && {quoted} --version"
);
let nonint = format!(
"uname -s -m 2>/dev/null; printf '\\n{COMPOUND_SEP}\\n'; test -x {quoted} && sudo -n {quoted} --version"
);
let passwd = format!(
"uname -s -m 2>/dev/null; printf '\\n{COMPOUND_SEP}\\n'; test -x {quoted} && sudo -S {quoted} --version"
);
if sudo == Sudo::None {
let (_, platform, version, _) = run_compound(peer, &plain, auth, Sudo::None, None).await?;
return Ok((
platform,
VersionProbe {
version,
sudo_password_required: false,
mode: Sudo::None,
},
));
}
let (code, platform, version, stderr) =
run_compound(peer, &nonint, auth, Sudo::NonInteractive, None).await?;
if code == 0 {
return Ok((
platform,
VersionProbe {
version,
sudo_password_required: false,
mode: Sudo::NonInteractive,
},
));
}
if String::from_utf8_lossy(&stderr)
.to_ascii_lowercase()
.contains("password")
{
let Some(pw) = sudo_password else {
return Ok((
platform,
VersionProbe {
version: None,
sudo_password_required: true,
mode: Sudo::NonInteractive,
},
));
};
let (code, platform, version, _) =
run_compound(peer, &passwd, auth, Sudo::Password, Some(pw)).await?;
if code == 0 {
return Ok((
platform,
VersionProbe {
version,
sudo_password_required: false,
mode: Sudo::Password,
},
));
}
return Err(Error::Other(
"the remote sudo password was rejected (sudo -S failed); check --sudo-password / --password"
.to_string(),
));
}
Ok((
platform,
VersionProbe {
version,
sudo_password_required: false,
mode: Sudo::NonInteractive,
},
))
}
async fn run_version_probe(
peer: &RemoteTarget,
remote_cmd: &str,
auth: &SshAuth<'_>,
sudo: Sudo,
sudo_password: Option<&str>,
) -> Result<(u32, Vec<u8>, Vec<u8>)> {
use tokio::io::AsyncWriteExt;
let stdin = if sudo == Sudo::Password {
Stdio::piped()
} else {
Stdio::null()
};
let stderr = if sudo == Sudo::NonInteractive {
Stdio::piped()
} else {
Stdio::inherit()
};
let mut child = ssh_command(peer, remote_cmd, auth)
.stdin(stdin)
.stdout(Stdio::piped())
.stderr(stderr)
.spawn()
.map_err(Error::Io)?;
if sudo == Sudo::Password {
let mut child_stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
child_stdin
.write_all(format!("{}
", sudo_password.unwrap_or_default()).as_bytes())
.await
.map_err(Error::Io)?;
child.stdin = Some(child_stdin);
}
let output = tokio::time::timeout(SSH_COMMAND_TIMEOUT, child.wait_with_output())
.await
.map_err(|_| {
Error::Other("timed out checking the remote cp2 version — the remote may be hung".to_string())
})?
.map_err(Error::Io)?;
let code = u32::try_from(output.status.code().unwrap_or(255)).unwrap_or(255);
Ok((code, output.stdout, output.stderr))
}
fn connection_error(peer: &RemoteTarget) -> Error {
Error::Other(format!(
"ssh connection to {}@{} failed (exit 255) while checking the remote cp2 — \
check the host, credentials, and host key",
peer.user, peer.host
))
}
pub async fn check_remote_platform(
peer: &RemoteTarget,
auth: &SshAuth<'_>,
) -> Result<Option<(String, String)>> {
let unix = probe_output(peer, "uname -s -m", auth).await?;
if let Some(platform) = parse_uname(&unix) {
return Ok(Some(platform));
}
let win = probe_output(peer, "cmd /c echo %PROCESSOR_ARCHITECTURE%", auth).await?;
let arch = win.split_whitespace().next().unwrap_or("");
let arch = match arch {
"AMD64" => "x86_64",
"ARM64" => "aarch64",
other => {
tracing::warn!(
"remote Windows architecture '{other}' is unsupported: no cp2 sidecar exists \
for it; the deploy to this host will fail"
);
return Ok(None);
}
};
Ok(Some(("windows".to_string(), arch.to_string())))
}
async fn probe_output(peer: &RemoteTarget, remote_cmd: &str, auth: &SshAuth<'_>) -> Result<String> {
if auth.password.is_some() || auth.jump_password.is_some() {
#[cfg(unix)]
{
let (code, out) = run_remote_with_password(peer, remote_cmd, auth).await?;
if code == 255 {
return Err(Error::Other(format!(
"ssh connection to {}@{} failed (exit 255) — check the credentials and \
host key",
peer.user, peer.host
)));
}
return Ok(String::from_utf8_lossy(&out).into_owned());
}
#[cfg(not(unix))]
{
return Err(Error::Other(
"--password/--jump-password needs the russh transport on Windows".to_string(),
));
}
}
ssh_output(peer, remote_cmd, auth).await
}
async fn ssh_output(peer: &RemoteTarget, remote_cmd: &str, auth: &SshAuth<'_>) -> Result<String> {
let output = tokio::time::timeout(
SSH_COMMAND_TIMEOUT,
ssh_command(peer, remote_cmd, auth)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.output(),
)
.await
.map_err(|_| {
Error::Other("timed out probing the remote — the remote may be hung".to_string())
})?
.map_err(Error::Io)?;
if output.status.code() == Some(255) {
return Err(Error::Other(format!(
"ssh connection to {}@{} failed (exit 255) — check the host, credentials, and \
host key",
peer.user, peer.host
)));
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
pub(crate) fn parse_uname(stdout: &str) -> Option<(String, String)> {
let parts: Vec<&str> = stdout.split_whitespace().collect();
let (os, arch) = (parts.first()?, parts.get(1)?);
normalize_platform(os, arch)
}
fn normalize_platform(os: &str, arch: &str) -> Option<(String, String)> {
let os = os.to_ascii_lowercase();
let arch = arch.to_ascii_lowercase();
let os = match os.as_str() {
"linux" => "linux",
"darwin" => "macos",
"windows" => "windows",
_ => return None,
};
let arch = match arch.as_str() {
"x86_64" | "amd64" => "x86_64",
"aarch64" | "arm64" => "aarch64",
_ => return None,
};
Some((os.to_string(), arch.to_string()))
}
pub(crate) fn remote_triple(os: &str, arch: &str) -> Option<&'static str> {
match (os, arch) {
("linux", "x86_64") => Some("x86_64-unknown-linux-musl"),
("linux", "aarch64") => Some("aarch64-unknown-linux-musl"),
("macos", "x86_64") => Some("x86_64-apple-darwin"),
("macos", "aarch64") => Some("aarch64-apple-darwin"),
("windows", "x86_64") => Some("x86_64-pc-windows-msvc"),
("windows", "aarch64") => Some("aarch64-pc-windows-msvc"),
_ => None,
}
}
#[must_use]
pub fn default_remote_path(os: &str) -> String {
match os {
"windows" => r"%USERPROFILE%\.cargo\bin\cp2.exe".to_string(),
_ => DEFAULT_REMOTE_PATH.to_string(),
}
}
pub(crate) fn remote_command(os: &str, command: &str) -> String {
match os {
"windows" => format!("cmd /c {command}"),
_ => command.to_string(),
}
}
#[must_use]
pub fn sidecar_candidates(os: &str, arch: &str) -> Vec<&'static str> {
match remote_triple(os, arch) {
Some("x86_64-pc-windows-msvc") => {
vec!["x86_64-pc-windows-msvc", "x86_64-pc-windows-gnu"]
}
Some("aarch64-pc-windows-msvc") => {
vec!["aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"]
}
Some(triple) => vec![triple],
None => Vec::new(),
}
}
#[must_use]
pub fn sidecar_path(triple: &str) -> std::path::PathBuf {
std::env::current_exe()
.ok()
.and_then(|exe| exe.parent().map(std::path::Path::to_path_buf))
.unwrap_or_else(|| std::path::PathBuf::from("."))
.join(format!("cp2-{triple}"))
}
pub(crate) fn local_platform() -> (String, String) {
(
std::env::consts::OS.to_string(),
std::env::consts::ARCH.to_string(),
)
}
pub(crate) fn parse_remote_version(stdout: &str) -> Option<(String, Option<String>)> {
let tokens: Vec<&str> = stdout.split_whitespace().collect();
let version = tokens.get(1)?.to_string();
let fingerprint = tokens
.windows(2)
.find(|w| w[0] == "(build")
.and_then(|w| {
let fp = w[1].trim_end_matches(')');
(fp.len() == 16 && fp.chars().all(|c| c.is_ascii_hexdigit())).then(|| fp.to_string())
});
Some((version, fingerprint))
}
fn shell_quote(path: &str) -> String {
let Some(rest) = path.strip_prefix('~') else {
return format!("'{}'", path.replace('\'', "'\\''"));
};
if rest.is_empty() {
return "~".to_string();
}
if let Some(after_slash) = rest.strip_prefix('/') {
format!("~/'{}'", after_slash.replace('\'', "'\\''"))
} else {
format!("'{}'", path.replace('\'', "'\\''"))
}
}
pub(crate) fn deploy_command(remote_os: &str, remote_path: &str) -> String {
if remote_os == "windows" {
windows_push_command(remote_path)
} else {
let dir = match remote_path.rfind('/') {
Some(i) => &remote_path[..i],
None => ".",
};
let quoted = shell_quote(remote_path);
let tmp = format!("{quoted}.tmp.$$");
format!(
"mkdir -p {} && cat > {tmp} && mv {tmp} {quoted} && chmod +x {quoted}",
shell_quote(dir)
)
}
}
pub(crate) fn deploy_serve_command(remote_path: &str, server_args: &str, size: u64) -> String {
let dir = match remote_path.rfind('/') {
Some(i) => &remote_path[..i],
None => ".",
};
let quoted = shell_quote(remote_path);
let tmp = format!("{quoted}.tmp.$$");
let base = if server_args.is_empty() {
format!("{quoted} --server")
} else {
format!("{quoted} --server {server_args}")
};
format!(
"mkdir -p {} && head -c {size} > {tmp} && mv {tmp} {quoted} && chmod +x {quoted} && exec {base}",
shell_quote(dir)
)
}
pub(crate) fn deploy_payload(remote_os: &str, local_binary: &Path) -> Result<Vec<u8>> {
match remote_os {
"windows" => Ok(base64::Engine::encode(
&base64::engine::general_purpose::STANDARD,
std::fs::read(local_binary).map_err(Error::Io)?,
)
.into_bytes()),
_ => std::fs::read(local_binary).map_err(Error::Io),
}
}
pub async fn push_remote_binary(
peer: &RemoteTarget,
remote_path: &str,
local_binary: &Path,
remote_os: &str,
auth: &SshAuth<'_>,
) -> Result<()> {
let remote_cmd = deploy_command(remote_os, remote_path);
let payload = deploy_payload(remote_os, local_binary)?;
let mut child = ssh_command(peer, &remote_cmd, auth)
.stdin(Stdio::piped())
.stdout(Stdio::inherit())
.stderr(if cfg!(unix) { Stdio::piped() } else { Stdio::inherit() })
.spawn()
.map_err(Error::Io)?;
if let Some(stderr) = child.stderr.take() {
drain_child_stderr(stderr);
}
let timed = tokio::time::timeout(SSH_COMMAND_TIMEOUT, async {
let mut stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
stdin.write_all(&payload).await.map_err(Error::Io)?;
drop(stdin); child.wait().await.map_err(Error::Io)
})
.await;
match timed {
Ok(Ok(status)) if status.success() => Ok(()),
Ok(Ok(status)) => Err(Error::Other(format!(
"failed to deploy cp2 to the server: ssh exited with {status}"
))),
Ok(Err(e)) => Err(e),
Err(_) => {
let _ = child.kill().await;
Err(Error::Other(
"timed out deploying cp2 to the server — the remote may be hung".to_string(),
))
}
}
}
pub async fn push_remote_binary_and_serve(
peer: &RemoteTarget,
remote_path: &str,
server_args: &str,
local_binary: &Path,
auth: &SshAuth<'_>,
) -> Result<(Child, ChildStdin, ChildStdout)> {
let payload = std::fs::read(local_binary).map_err(Error::Io)?;
let remote_cmd = deploy_serve_command(remote_path, server_args, payload.len() as u64);
let mut cmd = ssh_command(peer, &remote_cmd, auth);
cmd.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(if cfg!(unix) { Stdio::piped() } else { Stdio::inherit() });
let mut child = cmd.spawn().map_err(Error::Io)?;
if let Some(stderr) = child.stderr.take() {
drain_child_stderr(stderr);
}
let mut stdin = child
.stdin
.take()
.ok_or_else(|| Error::Other("ssh stdin unavailable".to_string()))?;
let stdout = child
.stdout
.take()
.ok_or_else(|| Error::Other("ssh stdout unavailable".to_string()))?;
crate::platform::fs::enlarge_pipe(&stdin);
crate::platform::fs::enlarge_pipe(&stdout);
stdin.write_all(&payload).await.map_err(Error::Io)?;
Ok((child, stdin, stdout))
}
pub(crate) fn windows_push_command(remote_path: &str) -> String {
format!(
r#"cmd /c powershell -NoProfile -Command "New-Item -Force -ItemType Directory (Split-Path -Parent '{remote_path}') | Out-Null; $t = $env:TEMP\cp2-$PID.b64; $input | Out-File -Encoding ascii -NoNewline $t; certutil -decode -f $t '{remote_path}'; del $t""#
)
}
#[cfg(unix)]
async fn run_remote_with_password(
peer: &RemoteTarget,
remote_cmd: &str,
auth: &SshAuth<'_>,
) -> Result<(u32, Vec<u8>)> {
use tokio::io::AsyncReadExt;
let (master, slave) = open_pty()?;
let mut cmd = Command::new("ssh");
cmd.arg("-p")
.arg(peer.port.to_string())
.arg(format!("{}@{}", peer.user, peer.host))
.args(multiplex_args_with(auth))
.arg("-o")
.arg("PubkeyAuthentication=no")
.arg("-o")
.arg("PreferredAuthentications=password,keyboard-interactive")
.arg(remote_cmd)
.stdin(Stdio::from(slave.try_clone().map_err(Error::Io)?))
.stdout(Stdio::piped())
.stderr(Stdio::from(slave));
let mut child = cmd.spawn().map_err(Error::Io)?;
let mut stdout = child
.stdout
.take()
.ok_or_else(|| Error::Other("ssh stdout unavailable".to_string()))?;
let injector_master = master.try_clone().map_err(Error::Io)?;
drop(master);
let mut passwords: Vec<String> = Vec::new();
if let Some(jump_password) = auth.jump_password {
passwords.push(jump_password.to_string());
}
if let Some(password) = auth.password {
passwords.push(password.to_string());
}
let injector = tokio::task::spawn_blocking(move || {
inject_password(injector_master, passwords);
});
let timed = tokio::time::timeout(SSH_COMMAND_TIMEOUT, async {
let mut out = Vec::new();
stdout.read_to_end(&mut out).await.map_err(Error::Io)?;
let status = child.wait().await.map_err(Error::Io)?;
let _ = injector.await;
let code = u32::try_from(status.code().unwrap_or(255)).unwrap_or(255);
Ok::<_, Error>((code, out))
})
.await;
match timed {
Ok(Ok((code, out))) => Ok((code, out)),
Ok(Err(e)) => Err(e),
Err(_) => {
let _ = child.kill().await;
Err(Error::Other(format!(
"timed out waiting for the ssh password prompt ({}s) — check the host key \
and credentials",
SSH_COMMAND_TIMEOUT.as_secs()
)))
}
}
}
#[cfg(unix)]
fn open_pty() -> std::io::Result<(std::fs::File, std::fs::File)> {
use std::os::fd::FromRawFd;
let mut master: libc::c_int = -1;
let mut slave: libc::c_int = -1;
let rc = unsafe {
libc::openpty(
std::ptr::addr_of_mut!(master),
std::ptr::addr_of_mut!(slave),
std::ptr::null_mut(),
std::ptr::null_mut(),
std::ptr::null_mut(),
)
};
if rc != 0 {
return Err(std::io::Error::last_os_error());
}
let mut termios: libc::termios = unsafe { std::mem::zeroed() };
if unsafe { libc::tcgetattr(slave, std::ptr::addr_of_mut!(termios)) } != 0 {
let e = std::io::Error::last_os_error();
unsafe {
libc::close(master);
libc::close(slave);
}
return Err(e);
}
unsafe { libc::cfmakeraw(std::ptr::addr_of_mut!(termios)) };
if unsafe { libc::tcsetattr(slave, libc::TCSANOW, std::ptr::addr_of!(termios)) } != 0 {
let e = std::io::Error::last_os_error();
unsafe {
libc::close(master);
libc::close(slave);
}
return Err(e);
}
Ok((
unsafe { std::fs::File::from_raw_fd(master) },
unsafe { std::fs::File::from_raw_fd(slave) },
))
}
#[cfg(unix)]
fn inject_password(master: std::fs::File, mut passwords: Vec<String>) {
use std::io::{Read, Write};
use zeroize::Zeroize;
let mut reader = master;
let Ok(mut writer) = reader.try_clone() else {
return;
};
let mut buf = [0u8; 1024];
let mut window: Vec<u8> = Vec::new();
let mut answered = 0usize;
while let Ok(n) = reader.read(&mut buf) {
if n == 0 {
break;
}
window.extend_from_slice(&buf[..n]);
if window.windows(8).any(|w| w == b"assword:") {
let password = &passwords[answered.min(passwords.len().saturating_sub(1))];
let _ = writer.write_all(password.as_bytes());
let _ = writer.write_all(b"\n");
answered += 1;
window.clear();
} else if window.windows(6).any(|w| w == b"yes/no")
|| window.windows(19).any(|w| w == b"continue connecting")
{
let _ = writer.write_all(b"no\n");
window.clear();
break;
}
if window.len() > 8192 {
window.drain(..window.len() - 1024);
}
}
for secret in &mut passwords {
secret.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::target::Location;
#[test]
fn server_invocation_plain_and_sudo() {
assert_eq!(
server_invocation("~/.cargo/bin/cp2", "linux", "", Sudo::None),
"~/'.cargo/bin/cp2' --server"
);
assert_eq!(
server_invocation("~/.cargo/bin/cp2", "linux", "--jobs 4", Sudo::None),
"~/'.cargo/bin/cp2' --server --jobs 4"
);
assert_eq!(
server_invocation("~/.cargo/bin/cp2", "linux", "--jobs 4", Sudo::NonInteractive),
"sudo -n ~/'.cargo/bin/cp2' --server --jobs 4"
);
assert_eq!(
server_invocation("~/.cargo/bin/cp2", "linux", "", Sudo::Password),
"sudo -S ~/'.cargo/bin/cp2' --server"
);
assert_eq!(
server_invocation("C:\\cp2.exe", "windows", "", Sudo::Password),
"sudo -S C:\\cp2.exe --server"
);
}
#[test]
fn parse_version_from_clap_output() {
assert_eq!(
parse_remote_version("cp2 0.1.0\n"),
Some(("0.1.0".to_string(), None))
);
assert_eq!(
parse_remote_version("cp2 0.1.0"),
Some(("0.1.0".to_string(), None))
);
assert_eq!(
parse_remote_version("cp2 0.1.0 (build 0123456789abcdef)"),
Some(("0.1.0".to_string(), Some("0123456789abcdef".to_string())))
);
assert_eq!(
parse_remote_version("cp2 0.2.0 (build fedcba9876543210)\n"),
Some(("0.2.0".to_string(), Some("fedcba9876543210".to_string())))
);
assert_eq!(parse_remote_version(""), None);
assert_eq!(parse_remote_version("cp2\n"), None);
assert_eq!(
parse_remote_version("cp2 0.1.0 (build ?)\n"),
Some(("0.1.0".to_string(), None))
);
}
#[cfg(unix)]
#[test]
fn pty_injection_answers_password_prompt() {
use std::process::{Command as StdCommand, Stdio};
let dir = tempfile::tempdir().unwrap();
let out = dir.path().join("out");
let (master, slave) = open_pty().unwrap();
let script = format!(
"p=pass; p=${{p}}word; printf 'user@host %s: ' \"$p\"; IFS= read -r line; printf 'got:%s\\n' \"$line\" > {}",
out.display()
);
let slave_in = slave.try_clone().unwrap();
let mut child = StdCommand::new("/bin/sh")
.arg("-c")
.arg(&script)
.stdin(Stdio::from(slave_in))
.stdout(Stdio::from(slave))
.spawn()
.unwrap();
let injector_master = master.try_clone().unwrap();
let handle = std::thread::spawn(move || {
inject_password(injector_master, vec!["unit-test-fake".to_string()]);
});
let status = child.wait().unwrap();
handle.join().unwrap();
assert!(status.success());
let got = std::fs::read_to_string(&out).unwrap();
assert_eq!(
got.trim(),
"got:unit-test-fake",
"the injected password must arrive intact"
);
}
#[cfg(unix)]
#[tokio::test]
async fn stderr_flood_never_stalls_the_child() {
use std::time::Duration;
let mut child = Command::new("/bin/sh")
.arg("-c")
.arg(
"i=0; while [ $i -lt 8000 ]; do echo 'stderr line number $i going out'; i=$((i+1)); done",
)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::piped())
.spawn()
.unwrap();
drain_child_stderr(child.stderr.take().unwrap());
let status = tokio::time::timeout(Duration::from_secs(30), child.wait())
.await
.expect("the child must finish promptly, not block on stderr")
.unwrap();
assert!(status.success());
}
#[test]
fn command_shape_is_rsync_like() {
let target = Location::parse("alice@backup.example.com:restore");
let Location::Remote(remote) = target else {
panic!("expected remote");
};
assert_eq!(remote.user, "alice");
assert_eq!(remote.host, "backup.example.com");
assert_eq!(remote.port, 22);
assert_eq!(remote.path, "restore");
}
#[test]
fn multiplex_args_share_one_master_per_peer() {
let args = multiplex_args_with(&SshAuth::default());
if cfg!(windows) {
assert!(args.is_empty(), "{args:?}");
return;
}
assert_eq!(args.len(), 6);
assert_eq!(args[0], "-o");
assert_eq!(args[1], "ControlMaster=auto");
assert_eq!(args[2], "-o");
let path = args[3].strip_prefix("ControlPath=").unwrap();
assert!(path.contains("%C"), "{path}");
assert!(!path.contains('\\'), "{path}");
assert_eq!(args[4], "-o");
assert_eq!(args[5], "ControlPersist=60");
let args = multiplex_args_with(&SshAuth {
password: Some("pw"),
..SshAuth::default()
});
assert_eq!(args[5], "ControlPersist=86400");
let args = multiplex_args_with(&SshAuth {
jump_password: Some("pw"),
..SshAuth::default()
});
assert_eq!(args[5], "ControlPersist=86400");
}
}
#[cfg(test)]
mod platform_tests {
use super::*;
#[test]
fn compound_probe_parses_platform_and_version() {
let out = "Linux x86_64\n\n__CP2_PROBE_SEP__\ncp2 0.1.1 (build 5ea78b018f24a474)\n";
let (platform, version) = parse_compound_probe(out);
assert_eq!(platform, Some(("linux".to_string(), "x86_64".to_string())));
let (v, fp) = version.unwrap();
assert_eq!(v, "0.1.1");
assert_eq!(fp.as_deref(), Some("5ea78b018f24a474"));
}
#[test]
fn compound_probe_missing_binary_reports_version_none() {
let out = "Linux x86_64\n\n__CP2_PROBE_SEP__\n";
let (platform, version) = parse_compound_probe(out);
assert_eq!(platform, Some(("linux".to_string(), "x86_64".to_string())));
assert_eq!(version, None);
}
#[test]
fn compound_probe_non_unix_remote_yields_no_platform() {
let out = "The system cannot find the path specified.\n";
let (platform, version) = parse_compound_probe(out);
assert_eq!(platform, None);
assert_eq!(version, None);
}
#[test]
fn parse_uname_chain() {
assert_eq!(
parse_uname("Linux x86_64\n"),
Some(("linux".to_string(), "x86_64".to_string()))
);
assert_eq!(parse_uname(""), None);
assert_eq!(parse_uname("cmd: uname not found"), None);
}
#[test]
fn preamble_command_quotes_and_execs() {
let cmd = preamble_command("~/.cargo/bin/cp2", "--jobs 4");
assert!(cmd.starts_with("uname -s -m 2>/dev/null; printf '\\n__CP2_PROBE_SEP__\\n'; exec "));
assert!(cmd.ends_with("--server --jobs 4"));
assert!(cmd.contains("~/'.cargo/bin/cp2'"));
let evil = preamble_command("x; rm -rf /", "");
assert!(evil.contains("'x; rm -rf /'"));
}
#[test]
fn preamble_marker_split_and_strip() {
let bytes = b"Linux x86_64\n\n__CP2_PROBE_SEP__\n\x00\x01\x02";
let idx = find_marker(bytes).expect("marker present");
let head = String::from_utf8_lossy(&bytes[..idx]);
assert_eq!(
parse_uname(head.trim()),
Some(("linux".to_string(), "x86_64".to_string()))
);
let marker_end = idx + COMPOUND_SEP.len();
let mut tail = marker_end;
while tail < bytes.len() && bytes[tail] == b'\n' {
tail += 1;
}
assert_eq!(&bytes[tail..], &[0x00, 0x01, 0x02]);
assert!(find_marker(b"no marker here").is_none());
}
#[test]
fn prefixed_reader_serves_prefix_then_stream() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut writer, reader) = tokio::io::duplex(64);
let mut prefixed = PrefixedReader::new(vec![0xAA, 0xBB], Box::new(reader));
let rt = tokio::runtime::Builder::new_current_thread()
.enable_io()
.build()
.unwrap();
rt.block_on(async {
writer.write_all(&[0xCC, 0xDD]).await.unwrap();
drop(writer);
let mut out = Vec::new();
prefixed.read_to_end(&mut out).await.unwrap();
assert_eq!(out, vec![0xAA, 0xBB, 0xCC, 0xDD]);
});
}
#[test]
fn windows_defaults_and_triples() {
assert_eq!(
default_remote_path("windows"),
r"%USERPROFILE%\.cargo\bin\cp2.exe"
);
assert_eq!(default_remote_path("linux"), DEFAULT_REMOTE_PATH);
assert_eq!(
remote_triple("windows", "x86_64"),
Some("x86_64-pc-windows-msvc")
);
assert_eq!(
remote_triple("windows", "aarch64"),
Some("aarch64-pc-windows-msvc")
);
assert_eq!(
remote_triple("linux", "x86_64"),
Some("x86_64-unknown-linux-musl")
);
}
#[test]
fn windows_push_command_shape() {
let cmd = windows_push_command(r"%USERPROFILE%\.local\\bin\\cp2.exe");
assert!(cmd.starts_with("cmd /c powershell -NoProfile -Command"));
assert!(cmd.contains("certutil -decode -f"));
assert!(cmd.contains("Split-Path -Parent"));
assert!(cmd.contains(r"$env:TEMP\cp2-$PID.b64"), "{cmd}");
}
#[test]
fn shell_quote_escapes_metacharacters() {
assert_eq!(shell_quote("~/.cargo/bin/cp2"), "~/'.cargo/bin/cp2'");
assert_eq!(shell_quote("~"), "~");
assert_eq!(shell_quote("/opt/cp2"), "'/opt/cp2'");
assert_eq!(shell_quote("rel/path"), "'rel/path'");
assert_eq!(shell_quote("a;rm -rf /'x"), "'a;rm -rf /'\\''x'");
assert_eq!(shell_quote("~alice/bin"), "'~alice/bin'");
}
#[test]
fn posix_deploy_streams_to_unique_temp_then_moves() {
let cmd = deploy_command("linux", "~/.cargo/bin/cp2");
assert!(cmd.contains("mkdir -p ~/'.cargo/bin'"), "{cmd}");
assert!(cmd.contains("cat > ~/'.cargo/bin/cp2'.tmp.$$"), "{cmd}");
assert!(
cmd.contains("mv ~/'.cargo/bin/cp2'.tmp.$$ ~/'.cargo/bin/cp2'"),
"{cmd}"
);
assert!(cmd.contains("chmod +x ~/'.cargo/bin/cp2'"), "{cmd}");
assert!(!cmd.contains("cat > ~/'.cargo/bin/cp2' &&"), "{cmd}");
assert!(!cmd.contains("~'/.cargo/bin/cp2'"), "{cmd}");
}
#[test]
fn normalize_uname_output() {
assert_eq!(
normalize_platform("Linux", "x86_64"),
Some(("linux".to_string(), "x86_64".to_string()))
);
assert_eq!(
normalize_platform("Darwin", "arm64"),
Some(("macos".to_string(), "aarch64".to_string()))
);
assert_eq!(
normalize_platform("Windows", "AMD64"),
Some(("windows".to_string(), "x86_64".to_string()))
);
assert_eq!(normalize_platform("Linux", "mips64"), None);
assert_eq!(normalize_platform("FreeBSD", "x86_64"), None);
}
}