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