1use crate::{
2 RemoteClientDelegate, RemotePlatform,
3 remote_client::{CommandTemplate, RemoteConnection, RemoteConnectionOptions},
4};
5use anyhow::{Context as _, Result, anyhow};
6use async_trait::async_trait;
7use collections::HashMap;
8use futures::{
9 AsyncReadExt as _, FutureExt as _,
10 channel::mpsc::{Sender, UnboundedReceiver, UnboundedSender},
11 select_biased,
12};
13use gpui::{App, AppContext as _, AsyncApp, SemanticVersion, Task};
14use itertools::Itertools;
15use parking_lot::Mutex;
16use paths::remote_server_dir_relative;
17use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
18use rpc::proto::Envelope;
19pub use settings::SshPortForwardOption;
20use smol::{
21 fs,
22 process::{self, Child, Stdio},
23};
24use std::{
25 iter,
26 path::{Path, PathBuf},
27 sync::Arc,
28 time::Instant,
29};
30use tempfile::TempDir;
31use util::{
32 paths::{PathStyle, RemotePathBuf},
33 rel_path::RelPath,
34};
35
36pub(crate) struct SshRemoteConnection {
37 socket: SshSocket,
38 master_process: Mutex<Option<Child>>,
39 remote_binary_path: Option<Arc<RelPath>>,
40 ssh_platform: RemotePlatform,
41 ssh_path_style: PathStyle,
42 ssh_shell: String,
43 ssh_default_system_shell: String,
44 _temp_dir: TempDir,
45}
46
47#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
48pub struct SshConnectionOptions {
49 pub host: String,
50 pub username: Option<String>,
51 pub port: Option<u16>,
52 pub password: Option<String>,
53 pub args: Option<Vec<String>>,
54 pub port_forwards: Option<Vec<SshPortForwardOption>>,
55
56 pub nickname: Option<String>,
57 pub upload_binary_over_ssh: bool,
58}
59
60impl From<settings::SshConnection> for SshConnectionOptions {
61 fn from(val: settings::SshConnection) -> Self {
62 SshConnectionOptions {
63 host: val.host.into(),
64 username: val.username,
65 port: val.port,
66 password: None,
67 args: Some(val.args),
68 nickname: val.nickname,
69 upload_binary_over_ssh: val.upload_binary_over_ssh.unwrap_or_default(),
70 port_forwards: val.port_forwards,
71 }
72 }
73}
74
75#[derive(Clone)]
76struct SshSocket {
77 connection_options: SshConnectionOptions,
78 #[cfg(not(target_os = "windows"))]
79 socket_path: PathBuf,
80 envs: HashMap<String, String>,
81 #[cfg(target_os = "windows")]
82 password: askpass::EncryptedPassword,
83}
84
85macro_rules! shell_script {
86 ($fmt:expr, $($name:ident = $arg:expr),+ $(,)?) => {{
87 format!(
88 $fmt,
89 $(
90 $name = shlex::try_quote($arg).unwrap()
91 ),+
92 )
93 }};
94}
95
96#[async_trait(?Send)]
97impl RemoteConnection for SshRemoteConnection {
98 async fn kill(&self) -> Result<()> {
99 let Some(mut process) = self.master_process.lock().take() else {
100 return Ok(());
101 };
102 process.kill().ok();
103 process.status().await?;
104 Ok(())
105 }
106
107 fn has_been_killed(&self) -> bool {
108 self.master_process.lock().is_none()
109 }
110
111 fn connection_options(&self) -> RemoteConnectionOptions {
112 RemoteConnectionOptions::Ssh(self.socket.connection_options.clone())
113 }
114
115 fn shell(&self) -> String {
116 self.ssh_shell.clone()
117 }
118
119 fn default_system_shell(&self) -> String {
120 self.ssh_default_system_shell.clone()
121 }
122
123 fn build_command(
124 &self,
125 input_program: Option<String>,
126 input_args: &[String],
127 input_env: &HashMap<String, String>,
128 working_dir: Option<String>,
129 port_forward: Option<(u16, String, u16)>,
130 ) -> Result<CommandTemplate> {
131 let Self {
132 ssh_path_style,
133 socket,
134 ssh_shell,
135 ..
136 } = self;
137 let env = socket.envs.clone();
138 build_command(
139 input_program,
140 input_args,
141 input_env,
142 working_dir,
143 port_forward,
144 env,
145 *ssh_path_style,
146 ssh_shell,
147 socket.ssh_args(),
148 )
149 }
150
151 fn upload_directory(
152 &self,
153 src_path: PathBuf,
154 dest_path: RemotePathBuf,
155 cx: &App,
156 ) -> Task<Result<()>> {
157 let mut command = util::command::new_smol_command("scp");
158 let output = self
159 .socket
160 .ssh_options(&mut command)
161 .args(
162 self.socket
163 .connection_options
164 .port
165 .map(|port| vec!["-P".to_string(), port.to_string()])
166 .unwrap_or_default(),
167 )
168 .arg("-C")
169 .arg("-r")
170 .arg(&src_path)
171 .arg(format!(
172 "{}:{}",
173 self.socket.connection_options.scp_url(),
174 dest_path
175 ))
176 .output();
177
178 cx.background_spawn(async move {
179 let output = output.await?;
180
181 anyhow::ensure!(
182 output.status.success(),
183 "failed to upload directory {} -> {}: {}",
184 src_path.display(),
185 dest_path.to_string(),
186 String::from_utf8_lossy(&output.stderr)
187 );
188
189 Ok(())
190 })
191 }
192
193 fn start_proxy(
194 &self,
195 unique_identifier: String,
196 reconnect: bool,
197 incoming_tx: UnboundedSender<Envelope>,
198 outgoing_rx: UnboundedReceiver<Envelope>,
199 connection_activity_tx: Sender<()>,
200 delegate: Arc<dyn RemoteClientDelegate>,
201 cx: &mut AsyncApp,
202 ) -> Task<Result<i32>> {
203 delegate.set_status(Some("Starting proxy"), cx);
204
205 let Some(remote_binary_path) = self.remote_binary_path.clone() else {
206 return Task::ready(Err(anyhow!("Remote binary path not set")));
207 };
208
209 let mut start_proxy_command = shell_script!(
210 "exec {binary_path} proxy --identifier {identifier}",
211 binary_path = &remote_binary_path.display(self.path_style()),
212 identifier = &unique_identifier,
213 );
214
215 for env_var in ["RUST_LOG", "RUST_BACKTRACE", "ZED_GENERATE_MINIDUMPS"] {
216 if let Some(value) = std::env::var(env_var).ok() {
217 start_proxy_command = format!(
218 "{}={} {} ",
219 env_var,
220 shlex::try_quote(&value).unwrap(),
221 start_proxy_command,
222 );
223 }
224 }
225
226 if reconnect {
227 start_proxy_command.push_str(" --reconnect");
228 }
229
230 let ssh_proxy_process = match self
231 .socket
232 .ssh_command("sh", &["-c", &start_proxy_command])
233 // IMPORTANT: we kill this process when we drop the task that uses it.
234 .kill_on_drop(true)
235 .spawn()
236 {
237 Ok(process) => process,
238 Err(error) => {
239 return Task::ready(Err(anyhow!("failed to spawn remote server: {}", error)));
240 }
241 };
242
243 super::handle_rpc_messages_over_child_process_stdio(
244 ssh_proxy_process,
245 incoming_tx,
246 outgoing_rx,
247 connection_activity_tx,
248 cx,
249 )
250 }
251
252 fn path_style(&self) -> PathStyle {
253 self.ssh_path_style
254 }
255}
256
257impl SshRemoteConnection {
258 pub(crate) async fn new(
259 connection_options: SshConnectionOptions,
260 delegate: Arc<dyn RemoteClientDelegate>,
261 cx: &mut AsyncApp,
262 ) -> Result<Self> {
263 use askpass::AskPassResult;
264
265 delegate.set_status(Some("Connecting"), cx);
266
267 let url = connection_options.ssh_url();
268
269 let temp_dir = tempfile::Builder::new()
270 .prefix("zed-ssh-session")
271 .tempdir()?;
272 let askpass_delegate = askpass::AskPassDelegate::new(cx, {
273 let delegate = delegate.clone();
274 move |prompt, tx, cx| delegate.ask_password(prompt, tx, cx)
275 });
276
277 let mut askpass =
278 askpass::AskPassSession::new(cx.background_executor(), askpass_delegate).await?;
279
280 // Start the master SSH process, which does not do anything except for establish
281 // the connection and keep it open, allowing other ssh commands to reuse it
282 // via a control socket.
283 #[cfg(not(target_os = "windows"))]
284 let socket_path = temp_dir.path().join("ssh.sock");
285
286 let mut master_process = {
287 #[cfg(not(target_os = "windows"))]
288 let args = [
289 "-N",
290 "-o",
291 "ControlPersist=no",
292 "-o",
293 "ControlMaster=yes",
294 "-o",
295 ];
296 // On Windows, `ControlMaster` and `ControlPath` are not supported:
297 // https://github.com/PowerShell/Win32-OpenSSH/issues/405
298 // https://github.com/PowerShell/Win32-OpenSSH/wiki/Project-Scope
299 #[cfg(target_os = "windows")]
300 let args = ["-N"];
301 let mut master_process = util::command::new_smol_command("ssh");
302 master_process
303 .kill_on_drop(true)
304 .stdin(Stdio::null())
305 .stdout(Stdio::piped())
306 .stderr(Stdio::piped())
307 .env("SSH_ASKPASS_REQUIRE", "force")
308 .env("SSH_ASKPASS", askpass.script_path())
309 .args(connection_options.additional_args())
310 .args(args);
311 #[cfg(not(target_os = "windows"))]
312 master_process.arg(format!("ControlPath={}", socket_path.display()));
313 master_process.arg(&url).spawn()?
314 };
315 // Wait for this ssh process to close its stdout, indicating that authentication
316 // has completed.
317 let mut stdout = master_process.stdout.take().unwrap();
318 let mut output = Vec::new();
319
320 let result = select_biased! {
321 result = askpass.run().fuse() => {
322 match result {
323 AskPassResult::CancelledByUser => {
324 master_process.kill().ok();
325 anyhow::bail!("SSH connection canceled")
326 }
327 AskPassResult::Timedout => {
328 anyhow::bail!("connecting to host timed out")
329 }
330 }
331 }
332 _ = stdout.read_to_end(&mut output).fuse() => {
333 anyhow::Ok(())
334 }
335 };
336
337 if let Err(e) = result {
338 return Err(e.context("Failed to connect to host"));
339 }
340
341 if master_process.try_status()?.is_some() {
342 output.clear();
343 let mut stderr = master_process.stderr.take().unwrap();
344 stderr.read_to_end(&mut output).await?;
345
346 let error_message = format!(
347 "failed to connect: {}",
348 String::from_utf8_lossy(&output).trim()
349 );
350 anyhow::bail!(error_message);
351 }
352
353 #[cfg(not(target_os = "windows"))]
354 let socket = SshSocket::new(connection_options, socket_path)?;
355 #[cfg(target_os = "windows")]
356 let socket = SshSocket::new(
357 connection_options,
358 &temp_dir,
359 askpass
360 .get_password()
361 .or_else(|| askpass::EncryptedPassword::try_from("").ok())
362 .context("Failed to fetch askpass password")?,
363 )?;
364 drop(askpass);
365
366 let ssh_platform = socket.platform().await?;
367 let ssh_path_style = match ssh_platform.os {
368 "windows" => PathStyle::Windows,
369 _ => PathStyle::Posix,
370 };
371 let ssh_shell = socket.shell().await;
372 let ssh_default_system_shell = String::from("/bin/sh");
373
374 let mut this = Self {
375 socket,
376 master_process: Mutex::new(Some(master_process)),
377 _temp_dir: temp_dir,
378 remote_binary_path: None,
379 ssh_path_style,
380 ssh_platform,
381 ssh_shell,
382 ssh_default_system_shell,
383 };
384
385 let (release_channel, version, commit) = cx.update(|cx| {
386 (
387 ReleaseChannel::global(cx),
388 AppVersion::global(cx),
389 AppCommitSha::try_global(cx),
390 )
391 })?;
392 this.remote_binary_path = Some(
393 this.ensure_server_binary(&delegate, release_channel, version, commit, cx)
394 .await?,
395 );
396
397 Ok(this)
398 }
399
400 async fn ensure_server_binary(
401 &self,
402 delegate: &Arc<dyn RemoteClientDelegate>,
403 release_channel: ReleaseChannel,
404 version: SemanticVersion,
405 commit: Option<AppCommitSha>,
406 cx: &mut AsyncApp,
407 ) -> Result<Arc<RelPath>> {
408 let version_str = match release_channel {
409 ReleaseChannel::Nightly => {
410 let commit = commit.map(|s| s.full()).unwrap_or_default();
411 format!("{}-{}", version, commit)
412 }
413 ReleaseChannel::Dev => "build".to_string(),
414 _ => version.to_string(),
415 };
416 let binary_name = format!(
417 "zed-remote-server-{}-{}",
418 release_channel.dev_name(),
419 version_str
420 );
421 let dst_path =
422 paths::remote_server_dir_relative().join(RelPath::unix(&binary_name).unwrap());
423
424 #[cfg(debug_assertions)]
425 if let Some(remote_server_path) =
426 super::build_remote_server_from_source(&self.ssh_platform, delegate.as_ref(), cx)
427 .await?
428 {
429 let tmp_path = paths::remote_server_dir_relative().join(
430 RelPath::unix(&format!(
431 "download-{}-{}",
432 std::process::id(),
433 remote_server_path.file_name().unwrap().to_string_lossy()
434 ))
435 .unwrap(),
436 );
437 self.upload_local_server_binary(&remote_server_path, &tmp_path, delegate, cx)
438 .await?;
439 self.extract_server_binary(&dst_path, &tmp_path, delegate, cx)
440 .await?;
441 return Ok(dst_path);
442 }
443
444 if self
445 .socket
446 .run_command(&dst_path.display(self.path_style()), &["version"])
447 .await
448 .is_ok()
449 {
450 return Ok(dst_path);
451 }
452
453 let wanted_version = cx.update(|cx| match release_channel {
454 ReleaseChannel::Nightly => Ok(None),
455 ReleaseChannel::Dev => {
456 anyhow::bail!(
457 "ZED_BUILD_REMOTE_SERVER is not set and no remote server exists at ({:?})",
458 dst_path
459 )
460 }
461 _ => Ok(Some(AppVersion::global(cx))),
462 })??;
463
464 let tmp_path_gz = remote_server_dir_relative().join(
465 RelPath::unix(&format!(
466 "{}-download-{}.gz",
467 binary_name,
468 std::process::id()
469 ))
470 .unwrap(),
471 );
472 if !self.socket.connection_options.upload_binary_over_ssh
473 && let Some((url, body)) = delegate
474 .get_download_params(self.ssh_platform, release_channel, wanted_version, cx)
475 .await?
476 {
477 match self
478 .download_binary_on_server(&url, &body, &tmp_path_gz, delegate, cx)
479 .await
480 {
481 Ok(_) => {
482 self.extract_server_binary(&dst_path, &tmp_path_gz, delegate, cx)
483 .await?;
484 return Ok(dst_path);
485 }
486 Err(e) => {
487 log::error!(
488 "Failed to download binary on server, attempting to upload server: {}",
489 e
490 )
491 }
492 }
493 }
494
495 let src_path = delegate
496 .download_server_binary_locally(self.ssh_platform, release_channel, wanted_version, cx)
497 .await?;
498 self.upload_local_server_binary(&src_path, &tmp_path_gz, delegate, cx)
499 .await?;
500 self.extract_server_binary(&dst_path, &tmp_path_gz, delegate, cx)
501 .await?;
502 Ok(dst_path)
503 }
504
505 async fn download_binary_on_server(
506 &self,
507 url: &str,
508 body: &str,
509 tmp_path_gz: &RelPath,
510 delegate: &Arc<dyn RemoteClientDelegate>,
511 cx: &mut AsyncApp,
512 ) -> Result<()> {
513 if let Some(parent) = tmp_path_gz.parent() {
514 self.socket
515 .run_command("mkdir", &["-p", parent.display(self.path_style()).as_ref()])
516 .await?;
517 }
518
519 delegate.set_status(Some("Downloading remote development server on host"), cx);
520
521 match self
522 .socket
523 .run_command(
524 "curl",
525 &[
526 "-f",
527 "-L",
528 "-X",
529 "GET",
530 "-H",
531 "Content-Type: application/json",
532 "-d",
533 body,
534 url,
535 "-o",
536 &tmp_path_gz.display(self.path_style()),
537 ],
538 )
539 .await
540 {
541 Ok(_) => {}
542 Err(e) => {
543 if self.socket.run_command("which", &["curl"]).await.is_ok() {
544 return Err(e);
545 }
546
547 match self
548 .socket
549 .run_command(
550 "wget",
551 &[
552 "--header=Content-Type: application/json",
553 "--body-data",
554 body,
555 url,
556 "-O",
557 &tmp_path_gz.display(self.path_style()),
558 ],
559 )
560 .await
561 {
562 Ok(_) => {}
563 Err(e) => {
564 if self.socket.run_command("which", &["wget"]).await.is_ok() {
565 return Err(e);
566 } else {
567 anyhow::bail!("Neither curl nor wget is available");
568 }
569 }
570 }
571 }
572 }
573
574 Ok(())
575 }
576
577 async fn upload_local_server_binary(
578 &self,
579 src_path: &Path,
580 tmp_path_gz: &RelPath,
581 delegate: &Arc<dyn RemoteClientDelegate>,
582 cx: &mut AsyncApp,
583 ) -> Result<()> {
584 if let Some(parent) = tmp_path_gz.parent() {
585 self.socket
586 .run_command("mkdir", &["-p", parent.display(self.path_style()).as_ref()])
587 .await?;
588 }
589
590 let src_stat = fs::metadata(&src_path).await?;
591 let size = src_stat.len();
592
593 let t0 = Instant::now();
594 delegate.set_status(Some("Uploading remote development server"), cx);
595 log::info!(
596 "uploading remote development server to {:?} ({}kb)",
597 tmp_path_gz,
598 size / 1024
599 );
600 self.upload_file(src_path, tmp_path_gz)
601 .await
602 .context("failed to upload server binary")?;
603 log::info!("uploaded remote development server in {:?}", t0.elapsed());
604 Ok(())
605 }
606
607 async fn extract_server_binary(
608 &self,
609 dst_path: &RelPath,
610 tmp_path: &RelPath,
611 delegate: &Arc<dyn RemoteClientDelegate>,
612 cx: &mut AsyncApp,
613 ) -> Result<()> {
614 delegate.set_status(Some("Extracting remote development server"), cx);
615 let server_mode = 0o755;
616
617 let orig_tmp_path = tmp_path.display(self.path_style());
618 let script = if let Some(tmp_path) = orig_tmp_path.strip_suffix(".gz") {
619 shell_script!(
620 "gunzip -f {orig_tmp_path} && chmod {server_mode} {tmp_path} && mv {tmp_path} {dst_path}",
621 server_mode = &format!("{:o}", server_mode),
622 dst_path = &dst_path.display(self.path_style()),
623 )
624 } else {
625 shell_script!(
626 "chmod {server_mode} {orig_tmp_path} && mv {orig_tmp_path} {dst_path}",
627 server_mode = &format!("{:o}", server_mode),
628 dst_path = &dst_path.display(self.path_style())
629 )
630 };
631 self.socket.run_command("sh", &["-c", &script]).await?;
632 Ok(())
633 }
634
635 async fn upload_file(&self, src_path: &Path, dest_path: &RelPath) -> Result<()> {
636 log::debug!("uploading file {:?} to {:?}", src_path, dest_path);
637 let mut command = util::command::new_smol_command("scp");
638 let output = self
639 .socket
640 .ssh_options(&mut command)
641 .args(
642 self.socket
643 .connection_options
644 .port
645 .map(|port| vec!["-P".to_string(), port.to_string()])
646 .unwrap_or_default(),
647 )
648 .arg(src_path)
649 .arg(format!(
650 "{}:{}",
651 self.socket.connection_options.scp_url(),
652 dest_path.display(self.path_style())
653 ))
654 .output()
655 .await?;
656
657 anyhow::ensure!(
658 output.status.success(),
659 "failed to upload file {} -> {}: {}",
660 src_path.display(),
661 dest_path.display(self.path_style()),
662 String::from_utf8_lossy(&output.stderr)
663 );
664 Ok(())
665 }
666}
667
668impl SshSocket {
669 #[cfg(not(target_os = "windows"))]
670 fn new(options: SshConnectionOptions, socket_path: PathBuf) -> Result<Self> {
671 Ok(Self {
672 connection_options: options,
673 envs: HashMap::default(),
674 socket_path,
675 })
676 }
677
678 #[cfg(target_os = "windows")]
679 fn new(
680 options: SshConnectionOptions,
681 temp_dir: &TempDir,
682 password: askpass::EncryptedPassword,
683 ) -> Result<Self> {
684 let askpass_script = temp_dir.path().join("askpass.bat");
685 std::fs::write(&askpass_script, "@ECHO OFF\necho %ZED_SSH_ASKPASS%")?;
686 let mut envs = HashMap::default();
687 envs.insert("SSH_ASKPASS_REQUIRE".into(), "force".into());
688 envs.insert("SSH_ASKPASS".into(), askpass_script.display().to_string());
689
690 Ok(Self {
691 connection_options: options,
692 envs,
693 password,
694 })
695 }
696
697 // :WARNING: ssh unquotes arguments when executing on the remote :WARNING:
698 // e.g. $ ssh host sh -c 'ls -l' is equivalent to $ ssh host sh -c ls -l
699 // and passes -l as an argument to sh, not to ls.
700 // Furthermore, some setups (e.g. Coder) will change directory when SSH'ing
701 // into a machine. You must use `cd` to get back to $HOME.
702 // You need to do it like this: $ ssh host "cd; sh -c 'ls -l /tmp'"
703 fn ssh_command(&self, program: &str, args: &[&str]) -> process::Command {
704 let mut command = util::command::new_smol_command("ssh");
705 let to_run = iter::once(&program)
706 .chain(args.iter())
707 .map(|token| {
708 // We're trying to work with: sh, bash, zsh, fish, tcsh, ...?
709 debug_assert!(
710 !token.contains('\n'),
711 "multiline arguments do not work in all shells"
712 );
713 shlex::try_quote(token).unwrap()
714 })
715 .join(" ");
716 let to_run = format!("cd; {to_run}");
717 log::debug!("ssh {} {:?}", self.connection_options.ssh_url(), to_run);
718 self.ssh_options(&mut command)
719 .arg(self.connection_options.ssh_url())
720 .arg("-T")
721 .arg(to_run);
722 command
723 }
724
725 async fn run_command(&self, program: &str, args: &[&str]) -> Result<String> {
726 let output = self.ssh_command(program, args).output().await?;
727 anyhow::ensure!(
728 output.status.success(),
729 "failed to run command: {}",
730 String::from_utf8_lossy(&output.stderr)
731 );
732 Ok(String::from_utf8_lossy(&output.stdout).to_string())
733 }
734
735 #[cfg(not(target_os = "windows"))]
736 fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
737 command
738 .stdin(Stdio::piped())
739 .stdout(Stdio::piped())
740 .stderr(Stdio::piped())
741 .args(self.connection_options.additional_args())
742 .args(["-o", "ControlMaster=no", "-o"])
743 .arg(format!("ControlPath={}", self.socket_path.display()))
744 }
745
746 #[cfg(target_os = "windows")]
747 fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
748 use askpass::ProcessExt;
749 command
750 .stdin(Stdio::piped())
751 .stdout(Stdio::piped())
752 .stderr(Stdio::piped())
753 .args(self.connection_options.additional_args())
754 .envs(self.envs.clone())
755 .encrypted_env("ZED_SSH_ASKPASS", self.password.clone())
756 }
757
758 // On Windows, we need to use `SSH_ASKPASS` to provide the password to ssh.
759 // On Linux, we use the `ControlPath` option to create a socket file that ssh can use to
760 #[cfg(not(target_os = "windows"))]
761 fn ssh_args(&self) -> Vec<String> {
762 let mut arguments = self.connection_options.additional_args();
763 arguments.extend(vec![
764 "-o".to_string(),
765 "ControlMaster=no".to_string(),
766 "-o".to_string(),
767 format!("ControlPath={}", self.socket_path.display()),
768 self.connection_options.ssh_url(),
769 ]);
770 arguments
771 }
772
773 #[cfg(target_os = "windows")]
774 fn ssh_args(&self) -> Vec<String> {
775 let mut arguments = self.connection_options.additional_args();
776 arguments.push(self.connection_options.ssh_url());
777 arguments
778 }
779
780 async fn platform(&self) -> Result<RemotePlatform> {
781 let uname = self.run_command("uname", &["-sm"]).await?;
782 let Some((os, arch)) = uname.split_once(" ") else {
783 anyhow::bail!("unknown uname: {uname:?}")
784 };
785
786 let os = match os.trim() {
787 "Darwin" => "macos",
788 "Linux" => "linux",
789 _ => anyhow::bail!(
790 "Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development"
791 ),
792 };
793 // exclude armv5,6,7 as they are 32-bit.
794 let arch = if arch.starts_with("armv8")
795 || arch.starts_with("armv9")
796 || arch.starts_with("arm64")
797 || arch.starts_with("aarch64")
798 {
799 "aarch64"
800 } else if arch.starts_with("x86") {
801 "x86_64"
802 } else {
803 anyhow::bail!(
804 "Prebuilt remote servers are not yet available for {arch:?}. See https://zed.dev/docs/remote-development"
805 )
806 };
807
808 Ok(RemotePlatform { os, arch })
809 }
810
811 async fn shell(&self) -> String {
812 match self.run_command("sh", &["-c", "echo $SHELL"]).await {
813 Ok(shell) => shell.trim().to_owned(),
814 Err(e) => {
815 log::error!("Failed to get shell: {e}");
816 "sh".to_owned()
817 }
818 }
819 }
820}
821
822fn parse_port_number(port_str: &str) -> Result<u16> {
823 port_str
824 .parse()
825 .with_context(|| format!("parsing port number: {port_str}"))
826}
827
828fn parse_port_forward_spec(spec: &str) -> Result<SshPortForwardOption> {
829 let parts: Vec<&str> = spec.split(':').collect();
830
831 match parts.len() {
832 4 => {
833 let local_port = parse_port_number(parts[1])?;
834 let remote_port = parse_port_number(parts[3])?;
835
836 Ok(SshPortForwardOption {
837 local_host: Some(parts[0].to_string()),
838 local_port,
839 remote_host: Some(parts[2].to_string()),
840 remote_port,
841 })
842 }
843 3 => {
844 let local_port = parse_port_number(parts[0])?;
845 let remote_port = parse_port_number(parts[2])?;
846
847 Ok(SshPortForwardOption {
848 local_host: None,
849 local_port,
850 remote_host: Some(parts[1].to_string()),
851 remote_port,
852 })
853 }
854 _ => anyhow::bail!("Invalid port forward format"),
855 }
856}
857
858impl SshConnectionOptions {
859 pub fn parse_command_line(input: &str) -> Result<Self> {
860 let input = input.trim_start_matches("ssh ");
861 let mut hostname: Option<String> = None;
862 let mut username: Option<String> = None;
863 let mut port: Option<u16> = None;
864 let mut args = Vec::new();
865 let mut port_forwards: Vec<SshPortForwardOption> = Vec::new();
866
867 // disallowed: -E, -e, -F, -f, -G, -g, -M, -N, -n, -O, -q, -S, -s, -T, -t, -V, -v, -W
868 const ALLOWED_OPTS: &[&str] = &[
869 "-4", "-6", "-A", "-a", "-C", "-K", "-k", "-X", "-x", "-Y", "-y",
870 ];
871 const ALLOWED_ARGS: &[&str] = &[
872 "-B", "-b", "-c", "-D", "-F", "-I", "-i", "-J", "-l", "-m", "-o", "-P", "-p", "-R",
873 "-w",
874 ];
875
876 let mut tokens = shlex::split(input).context("invalid input")?.into_iter();
877
878 'outer: while let Some(arg) = tokens.next() {
879 if ALLOWED_OPTS.contains(&(&arg as &str)) {
880 args.push(arg.to_string());
881 continue;
882 }
883 if arg == "-p" {
884 port = tokens.next().and_then(|arg| arg.parse().ok());
885 continue;
886 } else if let Some(p) = arg.strip_prefix("-p") {
887 port = p.parse().ok();
888 continue;
889 }
890 if arg == "-l" {
891 username = tokens.next();
892 continue;
893 } else if let Some(l) = arg.strip_prefix("-l") {
894 username = Some(l.to_string());
895 continue;
896 }
897 if arg == "-L" || arg.starts_with("-L") {
898 let forward_spec = if arg == "-L" {
899 tokens.next()
900 } else {
901 Some(arg.strip_prefix("-L").unwrap().to_string())
902 };
903
904 if let Some(spec) = forward_spec {
905 port_forwards.push(parse_port_forward_spec(&spec)?);
906 } else {
907 anyhow::bail!("Missing port forward format");
908 }
909 }
910
911 for a in ALLOWED_ARGS {
912 if arg == *a {
913 args.push(arg);
914 if let Some(next) = tokens.next() {
915 args.push(next);
916 }
917 continue 'outer;
918 } else if arg.starts_with(a) {
919 args.push(arg);
920 continue 'outer;
921 }
922 }
923 if arg.starts_with("-") || hostname.is_some() {
924 anyhow::bail!("unsupported argument: {:?}", arg);
925 }
926 let mut input = &arg as &str;
927 // Destination might be: username1@username2@ip2@ip1
928 if let Some((u, rest)) = input.rsplit_once('@') {
929 input = rest;
930 username = Some(u.to_string());
931 }
932 if let Some((rest, p)) = input.split_once(':') {
933 input = rest;
934 port = p.parse().ok()
935 }
936 hostname = Some(input.to_string())
937 }
938
939 let Some(hostname) = hostname else {
940 anyhow::bail!("missing hostname");
941 };
942
943 let port_forwards = match port_forwards.len() {
944 0 => None,
945 _ => Some(port_forwards),
946 };
947
948 Ok(Self {
949 host: hostname,
950 username,
951 port,
952 port_forwards,
953 args: Some(args),
954 password: None,
955 nickname: None,
956 upload_binary_over_ssh: false,
957 })
958 }
959
960 pub fn ssh_url(&self) -> String {
961 let mut result = String::from("ssh://");
962 if let Some(username) = &self.username {
963 // Username might be: username1@username2@ip2
964 let username = urlencoding::encode(username);
965 result.push_str(&username);
966 result.push('@');
967 }
968 result.push_str(&self.host);
969 if let Some(port) = self.port {
970 result.push(':');
971 result.push_str(&port.to_string());
972 }
973 result
974 }
975
976 pub fn additional_args(&self) -> Vec<String> {
977 let mut args = self.args.iter().flatten().cloned().collect::<Vec<String>>();
978
979 if let Some(forwards) = &self.port_forwards {
980 args.extend(forwards.iter().map(|pf| {
981 let local_host = match &pf.local_host {
982 Some(host) => host,
983 None => "localhost",
984 };
985 let remote_host = match &pf.remote_host {
986 Some(host) => host,
987 None => "localhost",
988 };
989
990 format!(
991 "-L{}:{}:{}:{}",
992 local_host, pf.local_port, remote_host, pf.remote_port
993 )
994 }));
995 }
996
997 args
998 }
999
1000 fn scp_url(&self) -> String {
1001 if let Some(username) = &self.username {
1002 format!("{}@{}", username, self.host)
1003 } else {
1004 self.host.clone()
1005 }
1006 }
1007
1008 pub fn connection_string(&self) -> String {
1009 let host = if let Some(username) = &self.username {
1010 format!("{}@{}", username, self.host)
1011 } else {
1012 self.host.clone()
1013 };
1014 if let Some(port) = &self.port {
1015 format!("{}:{}", host, port)
1016 } else {
1017 host
1018 }
1019 }
1020}
1021
1022fn build_command(
1023 input_program: Option<String>,
1024 input_args: &[String],
1025 input_env: &HashMap<String, String>,
1026 working_dir: Option<String>,
1027 port_forward: Option<(u16, String, u16)>,
1028 ssh_env: HashMap<String, String>,
1029 ssh_path_style: PathStyle,
1030 ssh_shell: &str,
1031 ssh_args: Vec<String>,
1032) -> Result<CommandTemplate> {
1033 use std::fmt::Write as _;
1034
1035 let mut exec = String::from("exec env -C ");
1036 if let Some(working_dir) = working_dir {
1037 let working_dir = RemotePathBuf::new(working_dir, ssh_path_style).to_string();
1038
1039 // shlex will wrap the command in single quotes (''), disabling ~ expansion,
1040 // replace with with something that works
1041 const TILDE_PREFIX: &'static str = "~/";
1042 if working_dir.starts_with(TILDE_PREFIX) {
1043 let working_dir = working_dir.trim_start_matches("~").trim_start_matches("/");
1044 write!(exec, "\"$HOME/{working_dir}\" ",).unwrap();
1045 } else {
1046 write!(exec, "\"{working_dir}\" ",).unwrap();
1047 }
1048 } else {
1049 write!(exec, "\"$HOME\" ").unwrap();
1050 };
1051
1052 for (k, v) in input_env.iter() {
1053 if let Some((k, v)) = shlex::try_quote(k).ok().zip(shlex::try_quote(v).ok()) {
1054 write!(exec, "{}={} ", k, v).unwrap();
1055 }
1056 }
1057
1058 if let Some(input_program) = input_program {
1059 write!(exec, "{}", shlex::try_quote(&input_program).unwrap()).unwrap();
1060 for arg in input_args {
1061 let arg = shlex::try_quote(&arg)?;
1062 write!(exec, " {}", &arg).unwrap();
1063 }
1064 } else {
1065 write!(exec, "{ssh_shell} -l").unwrap();
1066 };
1067
1068 let mut args = Vec::new();
1069 args.extend(ssh_args);
1070
1071 if let Some((local_port, host, remote_port)) = port_forward {
1072 args.push("-L".into());
1073 args.push(format!("{local_port}:{host}:{remote_port}"));
1074 }
1075
1076 args.push("-t".into());
1077 args.push(exec);
1078 Ok(CommandTemplate {
1079 program: "ssh".into(),
1080 args,
1081 env: ssh_env,
1082 })
1083}
1084
1085#[cfg(test)]
1086mod tests {
1087 use super::*;
1088
1089 #[test]
1090 fn test_build_command() -> Result<()> {
1091 let mut input_env = HashMap::default();
1092 input_env.insert("INPUT_VA".to_string(), "val".to_string());
1093 let mut env = HashMap::default();
1094 env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
1095
1096 let command = build_command(
1097 Some("remote_program".to_string()),
1098 &["arg1".to_string(), "arg2".to_string()],
1099 &input_env,
1100 Some("~/work".to_string()),
1101 None,
1102 env.clone(),
1103 PathStyle::Posix,
1104 "/bin/fish",
1105 vec!["-p".to_string(), "2222".to_string()],
1106 )?;
1107
1108 assert_eq!(command.program, "ssh");
1109 assert_eq!(
1110 command.args.iter().map(String::as_str).collect::<Vec<_>>(),
1111 [
1112 "-p",
1113 "2222",
1114 "-t",
1115 "exec env -C \"$HOME/work\" INPUT_VA=val remote_program arg1 arg2"
1116 ]
1117 );
1118 assert_eq!(command.env, env);
1119
1120 let mut input_env = HashMap::default();
1121 input_env.insert("INPUT_VA".to_string(), "val".to_string());
1122 let mut env = HashMap::default();
1123 env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
1124
1125 let command = build_command(
1126 None,
1127 &["arg1".to_string(), "arg2".to_string()],
1128 &input_env,
1129 None,
1130 Some((1, "foo".to_owned(), 2)),
1131 env.clone(),
1132 PathStyle::Posix,
1133 "/bin/fish",
1134 vec!["-p".to_string(), "2222".to_string()],
1135 )?;
1136
1137 assert_eq!(command.program, "ssh");
1138 assert_eq!(
1139 command.args.iter().map(String::as_str).collect::<Vec<_>>(),
1140 [
1141 "-p",
1142 "2222",
1143 "-L",
1144 "1:foo:2",
1145 "-t",
1146 "exec env -C \"$HOME\" INPUT_VA=val /bin/fish -l"
1147 ]
1148 );
1149 assert_eq!(command.env, env);
1150
1151 Ok(())
1152 }
1153}