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(
516 "sh",
517 &[
518 "-c",
519 &shell_script!(
520 "mkdir -p {parent}",
521 parent = parent.display(self.path_style()).as_ref()
522 ),
523 ],
524 )
525 .await?;
526 }
527
528 delegate.set_status(Some("Downloading remote development server on host"), cx);
529
530 match self
531 .socket
532 .run_command(
533 "curl",
534 &[
535 "-f",
536 "-L",
537 "-X",
538 "GET",
539 "-H",
540 "Content-Type: application/json",
541 "-d",
542 body,
543 url,
544 "-o",
545 &tmp_path_gz.display(self.path_style()),
546 ],
547 )
548 .await
549 {
550 Ok(_) => {}
551 Err(e) => {
552 if self.socket.run_command("which", &["curl"]).await.is_ok() {
553 return Err(e);
554 }
555
556 match self
557 .socket
558 .run_command(
559 "wget",
560 &[
561 "--header=Content-Type: application/json",
562 "--body-data",
563 body,
564 url,
565 "-O",
566 &tmp_path_gz.display(self.path_style()),
567 ],
568 )
569 .await
570 {
571 Ok(_) => {}
572 Err(e) => {
573 if self.socket.run_command("which", &["wget"]).await.is_ok() {
574 return Err(e);
575 } else {
576 anyhow::bail!("Neither curl nor wget is available");
577 }
578 }
579 }
580 }
581 }
582
583 Ok(())
584 }
585
586 async fn upload_local_server_binary(
587 &self,
588 src_path: &Path,
589 tmp_path_gz: &RelPath,
590 delegate: &Arc<dyn RemoteClientDelegate>,
591 cx: &mut AsyncApp,
592 ) -> Result<()> {
593 if let Some(parent) = tmp_path_gz.parent() {
594 self.socket
595 .run_command(
596 "sh",
597 &[
598 "-c",
599 &shell_script!(
600 "mkdir -p {parent}",
601 parent = parent.display(self.path_style()).as_ref()
602 ),
603 ],
604 )
605 .await?;
606 }
607
608 let src_stat = fs::metadata(&src_path).await?;
609 let size = src_stat.len();
610
611 let t0 = Instant::now();
612 delegate.set_status(Some("Uploading remote development server"), cx);
613 log::info!(
614 "uploading remote development server to {:?} ({}kb)",
615 tmp_path_gz,
616 size / 1024
617 );
618 self.upload_file(src_path, tmp_path_gz)
619 .await
620 .context("failed to upload server binary")?;
621 log::info!("uploaded remote development server in {:?}", t0.elapsed());
622 Ok(())
623 }
624
625 async fn extract_server_binary(
626 &self,
627 dst_path: &RelPath,
628 tmp_path: &RelPath,
629 delegate: &Arc<dyn RemoteClientDelegate>,
630 cx: &mut AsyncApp,
631 ) -> Result<()> {
632 delegate.set_status(Some("Extracting remote development server"), cx);
633 let server_mode = 0o755;
634
635 let orig_tmp_path = tmp_path.display(self.path_style());
636 let script = if let Some(tmp_path) = orig_tmp_path.strip_suffix(".gz") {
637 shell_script!(
638 "gunzip -f {orig_tmp_path} && chmod {server_mode} {tmp_path} && mv {tmp_path} {dst_path}",
639 server_mode = &format!("{:o}", server_mode),
640 dst_path = &dst_path.display(self.path_style()),
641 )
642 } else {
643 shell_script!(
644 "chmod {server_mode} {orig_tmp_path} && mv {orig_tmp_path} {dst_path}",
645 server_mode = &format!("{:o}", server_mode),
646 dst_path = &dst_path.display(self.path_style())
647 )
648 };
649 self.socket.run_command("sh", &["-c", &script]).await?;
650 Ok(())
651 }
652
653 async fn upload_file(&self, src_path: &Path, dest_path: &RelPath) -> Result<()> {
654 log::debug!("uploading file {:?} to {:?}", src_path, dest_path);
655 let mut command = util::command::new_smol_command("scp");
656 let output = self
657 .socket
658 .ssh_options(&mut command)
659 .args(
660 self.socket
661 .connection_options
662 .port
663 .map(|port| vec!["-P".to_string(), port.to_string()])
664 .unwrap_or_default(),
665 )
666 .arg(src_path)
667 .arg(format!(
668 "{}:{}",
669 self.socket.connection_options.scp_url(),
670 dest_path.display(self.path_style())
671 ))
672 .output()
673 .await?;
674
675 anyhow::ensure!(
676 output.status.success(),
677 "failed to upload file {} -> {}: {}",
678 src_path.display(),
679 dest_path.display(self.path_style()),
680 String::from_utf8_lossy(&output.stderr)
681 );
682 Ok(())
683 }
684}
685
686impl SshSocket {
687 #[cfg(not(target_os = "windows"))]
688 fn new(options: SshConnectionOptions, socket_path: PathBuf) -> Result<Self> {
689 Ok(Self {
690 connection_options: options,
691 envs: HashMap::default(),
692 socket_path,
693 })
694 }
695
696 #[cfg(target_os = "windows")]
697 fn new(
698 options: SshConnectionOptions,
699 temp_dir: &TempDir,
700 password: askpass::EncryptedPassword,
701 ) -> Result<Self> {
702 let askpass_script = temp_dir.path().join("askpass.bat");
703 std::fs::write(&askpass_script, "@ECHO OFF\necho %ZED_SSH_ASKPASS%")?;
704 let mut envs = HashMap::default();
705 envs.insert("SSH_ASKPASS_REQUIRE".into(), "force".into());
706 envs.insert("SSH_ASKPASS".into(), askpass_script.display().to_string());
707
708 Ok(Self {
709 connection_options: options,
710 envs,
711 password,
712 })
713 }
714
715 // :WARNING: ssh unquotes arguments when executing on the remote :WARNING:
716 // e.g. $ ssh host sh -c 'ls -l' is equivalent to $ ssh host sh -c ls -l
717 // and passes -l as an argument to sh, not to ls.
718 // Furthermore, some setups (e.g. Coder) will change directory when SSH'ing
719 // into a machine. You must use `cd` to get back to $HOME.
720 // You need to do it like this: $ ssh host "cd; sh -c 'ls -l /tmp'"
721 fn ssh_command(&self, program: &str, args: &[&str]) -> process::Command {
722 let mut command = util::command::new_smol_command("ssh");
723 let to_run = iter::once(&program)
724 .chain(args.iter())
725 .map(|token| {
726 // We're trying to work with: sh, bash, zsh, fish, tcsh, ...?
727 debug_assert!(
728 !token.contains('\n'),
729 "multiline arguments do not work in all shells"
730 );
731 shlex::try_quote(token).unwrap()
732 })
733 .join(" ");
734 let to_run = format!("cd; {to_run}");
735 log::debug!("ssh {} {:?}", self.connection_options.ssh_url(), to_run);
736 self.ssh_options(&mut command)
737 .arg(self.connection_options.ssh_url())
738 .arg(to_run);
739 command
740 }
741
742 async fn run_command(&self, program: &str, args: &[&str]) -> Result<String> {
743 let output = self.ssh_command(program, args).output().await?;
744 anyhow::ensure!(
745 output.status.success(),
746 "failed to run command: {}",
747 String::from_utf8_lossy(&output.stderr)
748 );
749 Ok(String::from_utf8_lossy(&output.stdout).to_string())
750 }
751
752 #[cfg(not(target_os = "windows"))]
753 fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
754 command
755 .stdin(Stdio::piped())
756 .stdout(Stdio::piped())
757 .stderr(Stdio::piped())
758 .args(self.connection_options.additional_args())
759 .args(["-o", "ControlMaster=no", "-o"])
760 .arg(format!("ControlPath={}", self.socket_path.display()))
761 }
762
763 #[cfg(target_os = "windows")]
764 fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
765 use askpass::ProcessExt;
766 command
767 .stdin(Stdio::piped())
768 .stdout(Stdio::piped())
769 .stderr(Stdio::piped())
770 .args(self.connection_options.additional_args())
771 .envs(self.envs.clone())
772 .encrypted_env("ZED_SSH_ASKPASS", self.password.clone())
773 }
774
775 // On Windows, we need to use `SSH_ASKPASS` to provide the password to ssh.
776 // On Linux, we use the `ControlPath` option to create a socket file that ssh can use to
777 #[cfg(not(target_os = "windows"))]
778 fn ssh_args(&self) -> Vec<String> {
779 let mut arguments = self.connection_options.additional_args();
780 arguments.extend(vec![
781 "-o".to_string(),
782 "ControlMaster=no".to_string(),
783 "-o".to_string(),
784 format!("ControlPath={}", self.socket_path.display()),
785 self.connection_options.ssh_url(),
786 ]);
787 arguments
788 }
789
790 #[cfg(target_os = "windows")]
791 fn ssh_args(&self) -> Vec<String> {
792 let mut arguments = self.connection_options.additional_args();
793 arguments.push(self.connection_options.ssh_url());
794 arguments
795 }
796
797 async fn platform(&self) -> Result<RemotePlatform> {
798 let uname = self.run_command("sh", &["-c", "uname -sm"]).await?;
799 let Some((os, arch)) = uname.split_once(" ") else {
800 anyhow::bail!("unknown uname: {uname:?}")
801 };
802
803 let os = match os.trim() {
804 "Darwin" => "macos",
805 "Linux" => "linux",
806 _ => anyhow::bail!(
807 "Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development"
808 ),
809 };
810 // exclude armv5,6,7 as they are 32-bit.
811 let arch = if arch.starts_with("armv8")
812 || arch.starts_with("armv9")
813 || arch.starts_with("arm64")
814 || arch.starts_with("aarch64")
815 {
816 "aarch64"
817 } else if arch.starts_with("x86") {
818 "x86_64"
819 } else {
820 anyhow::bail!(
821 "Prebuilt remote servers are not yet available for {arch:?}. See https://zed.dev/docs/remote-development"
822 )
823 };
824
825 Ok(RemotePlatform { os, arch })
826 }
827
828 async fn shell(&self) -> String {
829 match self.run_command("sh", &["-c", "echo $SHELL"]).await {
830 Ok(shell) => shell.trim().to_owned(),
831 Err(e) => {
832 log::error!("Failed to get shell: {e}");
833 "sh".to_owned()
834 }
835 }
836 }
837}
838
839fn parse_port_number(port_str: &str) -> Result<u16> {
840 port_str
841 .parse()
842 .with_context(|| format!("parsing port number: {port_str}"))
843}
844
845fn parse_port_forward_spec(spec: &str) -> Result<SshPortForwardOption> {
846 let parts: Vec<&str> = spec.split(':').collect();
847
848 match parts.len() {
849 4 => {
850 let local_port = parse_port_number(parts[1])?;
851 let remote_port = parse_port_number(parts[3])?;
852
853 Ok(SshPortForwardOption {
854 local_host: Some(parts[0].to_string()),
855 local_port,
856 remote_host: Some(parts[2].to_string()),
857 remote_port,
858 })
859 }
860 3 => {
861 let local_port = parse_port_number(parts[0])?;
862 let remote_port = parse_port_number(parts[2])?;
863
864 Ok(SshPortForwardOption {
865 local_host: None,
866 local_port,
867 remote_host: Some(parts[1].to_string()),
868 remote_port,
869 })
870 }
871 _ => anyhow::bail!("Invalid port forward format"),
872 }
873}
874
875impl SshConnectionOptions {
876 pub fn parse_command_line(input: &str) -> Result<Self> {
877 let input = input.trim_start_matches("ssh ");
878 let mut hostname: Option<String> = None;
879 let mut username: Option<String> = None;
880 let mut port: Option<u16> = None;
881 let mut args = Vec::new();
882 let mut port_forwards: Vec<SshPortForwardOption> = Vec::new();
883
884 // disallowed: -E, -e, -F, -f, -G, -g, -M, -N, -n, -O, -q, -S, -s, -T, -t, -V, -v, -W
885 const ALLOWED_OPTS: &[&str] = &[
886 "-4", "-6", "-A", "-a", "-C", "-K", "-k", "-X", "-x", "-Y", "-y",
887 ];
888 const ALLOWED_ARGS: &[&str] = &[
889 "-B", "-b", "-c", "-D", "-F", "-I", "-i", "-J", "-l", "-m", "-o", "-P", "-p", "-R",
890 "-w",
891 ];
892
893 let mut tokens = shlex::split(input).context("invalid input")?.into_iter();
894
895 'outer: while let Some(arg) = tokens.next() {
896 if ALLOWED_OPTS.contains(&(&arg as &str)) {
897 args.push(arg.to_string());
898 continue;
899 }
900 if arg == "-p" {
901 port = tokens.next().and_then(|arg| arg.parse().ok());
902 continue;
903 } else if let Some(p) = arg.strip_prefix("-p") {
904 port = p.parse().ok();
905 continue;
906 }
907 if arg == "-l" {
908 username = tokens.next();
909 continue;
910 } else if let Some(l) = arg.strip_prefix("-l") {
911 username = Some(l.to_string());
912 continue;
913 }
914 if arg == "-L" || arg.starts_with("-L") {
915 let forward_spec = if arg == "-L" {
916 tokens.next()
917 } else {
918 Some(arg.strip_prefix("-L").unwrap().to_string())
919 };
920
921 if let Some(spec) = forward_spec {
922 port_forwards.push(parse_port_forward_spec(&spec)?);
923 } else {
924 anyhow::bail!("Missing port forward format");
925 }
926 }
927
928 for a in ALLOWED_ARGS {
929 if arg == *a {
930 args.push(arg);
931 if let Some(next) = tokens.next() {
932 args.push(next);
933 }
934 continue 'outer;
935 } else if arg.starts_with(a) {
936 args.push(arg);
937 continue 'outer;
938 }
939 }
940 if arg.starts_with("-") || hostname.is_some() {
941 anyhow::bail!("unsupported argument: {:?}", arg);
942 }
943 let mut input = &arg as &str;
944 // Destination might be: username1@username2@ip2@ip1
945 if let Some((u, rest)) = input.rsplit_once('@') {
946 input = rest;
947 username = Some(u.to_string());
948 }
949 if let Some((rest, p)) = input.split_once(':') {
950 input = rest;
951 port = p.parse().ok()
952 }
953 hostname = Some(input.to_string())
954 }
955
956 let Some(hostname) = hostname else {
957 anyhow::bail!("missing hostname");
958 };
959
960 let port_forwards = match port_forwards.len() {
961 0 => None,
962 _ => Some(port_forwards),
963 };
964
965 Ok(Self {
966 host: hostname,
967 username,
968 port,
969 port_forwards,
970 args: Some(args),
971 password: None,
972 nickname: None,
973 upload_binary_over_ssh: false,
974 })
975 }
976
977 pub fn ssh_url(&self) -> String {
978 let mut result = String::from("ssh://");
979 if let Some(username) = &self.username {
980 // Username might be: username1@username2@ip2
981 let username = urlencoding::encode(username);
982 result.push_str(&username);
983 result.push('@');
984 }
985 result.push_str(&self.host);
986 if let Some(port) = self.port {
987 result.push(':');
988 result.push_str(&port.to_string());
989 }
990 result
991 }
992
993 pub fn additional_args(&self) -> Vec<String> {
994 let mut args = self.args.iter().flatten().cloned().collect::<Vec<String>>();
995
996 if let Some(forwards) = &self.port_forwards {
997 args.extend(forwards.iter().map(|pf| {
998 let local_host = match &pf.local_host {
999 Some(host) => host,
1000 None => "localhost",
1001 };
1002 let remote_host = match &pf.remote_host {
1003 Some(host) => host,
1004 None => "localhost",
1005 };
1006
1007 format!(
1008 "-L{}:{}:{}:{}",
1009 local_host, pf.local_port, remote_host, pf.remote_port
1010 )
1011 }));
1012 }
1013
1014 args
1015 }
1016
1017 fn scp_url(&self) -> String {
1018 if let Some(username) = &self.username {
1019 format!("{}@{}", username, self.host)
1020 } else {
1021 self.host.clone()
1022 }
1023 }
1024
1025 pub fn connection_string(&self) -> String {
1026 let host = if let Some(username) = &self.username {
1027 format!("{}@{}", username, self.host)
1028 } else {
1029 self.host.clone()
1030 };
1031 if let Some(port) = &self.port {
1032 format!("{}:{}", host, port)
1033 } else {
1034 host
1035 }
1036 }
1037}
1038
1039fn build_command(
1040 input_program: Option<String>,
1041 input_args: &[String],
1042 input_env: &HashMap<String, String>,
1043 working_dir: Option<String>,
1044 port_forward: Option<(u16, String, u16)>,
1045 ssh_env: HashMap<String, String>,
1046 ssh_path_style: PathStyle,
1047 ssh_shell: &str,
1048 ssh_args: Vec<String>,
1049) -> Result<CommandTemplate> {
1050 use std::fmt::Write as _;
1051
1052 let mut exec = String::from("exec env -C ");
1053 if let Some(working_dir) = working_dir {
1054 let working_dir = RemotePathBuf::new(working_dir, ssh_path_style).to_string();
1055
1056 // shlex will wrap the command in single quotes (''), disabling ~ expansion,
1057 // replace with with something that works
1058 const TILDE_PREFIX: &'static str = "~/";
1059 if working_dir.starts_with(TILDE_PREFIX) {
1060 let working_dir = working_dir.trim_start_matches("~").trim_start_matches("/");
1061 write!(exec, "\"$HOME/{working_dir}\" ",).unwrap();
1062 } else {
1063 write!(exec, "\"{working_dir}\" ",).unwrap();
1064 }
1065 } else {
1066 write!(exec, "\"$HOME\" ").unwrap();
1067 };
1068
1069 for (k, v) in input_env.iter() {
1070 if let Some((k, v)) = shlex::try_quote(k).ok().zip(shlex::try_quote(v).ok()) {
1071 write!(exec, "{}={} ", k, v).unwrap();
1072 }
1073 }
1074
1075 write!(exec, "{ssh_shell} ").unwrap();
1076 if let Some(input_program) = input_program {
1077 let mut script = shlex::try_quote(&input_program)?.into_owned();
1078 for arg in input_args {
1079 let arg = shlex::try_quote(&arg)?;
1080 script.push_str(" ");
1081 script.push_str(&arg);
1082 }
1083 write!(exec, "-c {}", shlex::try_quote(&script).unwrap()).unwrap();
1084 } else {
1085 write!(exec, "-l").unwrap();
1086 };
1087
1088 let mut args = Vec::new();
1089 args.extend(ssh_args);
1090
1091 if let Some((local_port, host, remote_port)) = port_forward {
1092 args.push("-L".into());
1093 args.push(format!("{local_port}:{host}:{remote_port}"));
1094 }
1095
1096 args.push("-t".into());
1097 args.push(exec);
1098 Ok(CommandTemplate {
1099 program: "ssh".into(),
1100 args,
1101 env: ssh_env,
1102 })
1103}
1104
1105#[cfg(test)]
1106mod tests {
1107 use super::*;
1108
1109 #[test]
1110 fn test_build_command() -> Result<()> {
1111 let mut input_env = HashMap::default();
1112 input_env.insert("INPUT_VA".to_string(), "val".to_string());
1113 let mut env = HashMap::default();
1114 env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
1115
1116 let command = build_command(
1117 Some("remote_program".to_string()),
1118 &["arg1".to_string(), "arg2".to_string()],
1119 &input_env,
1120 Some("~/work".to_string()),
1121 None,
1122 env.clone(),
1123 PathStyle::Posix,
1124 "/bin/fish",
1125 vec!["-p".to_string(), "2222".to_string()],
1126 )?;
1127
1128 assert_eq!(command.program, "ssh");
1129 assert_eq!(
1130 command.args.iter().map(String::as_str).collect::<Vec<_>>(),
1131 [
1132 "-p",
1133 "2222",
1134 "-t",
1135 "exec env -C \"$HOME/work\" INPUT_VA=val /bin/fish -c 'remote_program arg1 arg2'"
1136 ]
1137 );
1138 assert_eq!(command.env, env);
1139
1140 let mut input_env = HashMap::default();
1141 input_env.insert("INPUT_VA".to_string(), "val".to_string());
1142 let mut env = HashMap::default();
1143 env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
1144
1145 let command = build_command(
1146 None,
1147 &["arg1".to_string(), "arg2".to_string()],
1148 &input_env,
1149 None,
1150 Some((1, "foo".to_owned(), 2)),
1151 env.clone(),
1152 PathStyle::Posix,
1153 "/bin/fish",
1154 vec!["-p".to_string(), "2222".to_string()],
1155 )?;
1156
1157 assert_eq!(command.program, "ssh");
1158 assert_eq!(
1159 command.args.iter().map(String::as_str).collect::<Vec<_>>(),
1160 [
1161 "-p",
1162 "2222",
1163 "-L",
1164 "1:foo:2",
1165 "-t",
1166 "exec env -C \"$HOME\" INPUT_VA=val /bin/fish -l"
1167 ]
1168 );
1169 assert_eq!(command.env, env);
1170
1171 Ok(())
1172 }
1173}