Merge pull request #66 from openssh-rust/feature/support-subsystem

Feature/support subsystem

Author: jonhoo

Cargo.toml

@@ -55,6 +55,7 @@ openssh-mux-client = { version = "0.15.0", optional = true }
 lazy_static = "1.4.0"
 regex = "1"
 tokio = { version = "1", features = [ "full" ] }
+openssh-sftp-client = "0.10.0"
 
 [[example]]
 name = "native-mux_tsp"

src/changelog.rs

@@ -2,6 +2,9 @@
 use crate::*;
 
 /// TODO: RENAME THIS INTO THE NEXT VERSION BEFORE RELEASE
+///
+/// ## Added
+///  - [`Session::subsystem`]
 #[doc(hidden)]
 pub mod unreleased {}
 

src/lib.rs

@@ -111,6 +111,10 @@
 //! [`raw_args`](Command::raw_args), and [`raw_command`](Session::raw_command) to bypass the
 //! escaping that `openssh` normally does for you.
 //!
+//! # Sftp subsystem
+//!
+//! For sftp and other ssh subsystem, check [`Session::subsystem`] for more information.
+//!
 //! # Examples
 //!
 //! ```rust,no_run

src/native_mux_impl/command.rs

@@ -13,17 +13,19 @@ use openssh_mux_client::{Connection, NonZeroByteSlice, Session};
 pub(crate) struct Command {
     cmd: Vec<u8>,
     ctl: Box<Path>,
+    subsystem: bool,
 
     stdin_v: Stdio,
     stdout_v: Stdio,
     stderr_v: Stdio,
 }
 
 impl Command {
-    pub(crate) fn new(ctl: Box<Path>, cmd: Vec<u8>) -> Self {
+    pub(crate) fn new(ctl: Box<Path>, cmd: Vec<u8>, subsystem: bool) -> Self {
         Self {
             cmd,
             ctl,
+            subsystem,
 
             stdin_v: Stdio::inherit(),
             stdout_v: Stdio::inherit(),
@@ -71,7 +73,10 @@ impl Command {
 
         let cmd = NonZeroByteSlice::new(&self.cmd).ok_or(Error::InvalidCommand)?;
 
-        let session = Session::builder().cmd(Cow::Borrowed(cmd)).build();
+        let session = Session::builder()
+            .cmd(Cow::Borrowed(cmd))
+            .subsystem(self.subsystem)
+            .build();
 
         let established_session = Connection::connect(&self.ctl)
             .await?

src/native_mux_impl/session.rs

@@ -38,7 +38,11 @@ impl Session {
     }
 
     pub(crate) fn raw_command<S: AsRef<OsStr>>(&self, program: S) -> Command {
-        Command::new(self.ctl.clone(), program.as_ref().as_bytes().into())
+        Command::new(self.ctl.clone(), program.as_ref().as_bytes().into(), false)
+    }
+
+    pub(crate) fn subsystem<S: AsRef<OsStr>>(&self, program: S) -> Command {
+        Command::new(self.ctl.clone(), program.as_ref().as_bytes().into(), true)
     }
 
     pub(crate) async fn request_port_forward(

src/process_impl/session.rs

@@ -81,6 +81,18 @@ impl Session {
         Command::new(cmd)
     }
 
+    pub(crate) fn subsystem<S: AsRef<OsStr>>(&self, program: S) -> Command {
+        // XXX: Should we do a self.check() here first?
+
+        // NOTE: we pass -p 9 nine here (the "discard" port) to ensure that ssh does not
+        // succeed in establishing a _new_ connection if the master connection has failed.
+
+        let mut cmd = self.new_cmd(&["-T", "-p", "9", "-s"]);
+        cmd.arg("--").arg(program);
+
+        Command::new(cmd)
+    }
+
     pub(crate) async fn request_port_forward(
         &self,
         forward_type: impl Into<ForwardType>,

src/session.rs

@@ -166,6 +166,63 @@ impl Session {
         )
     }
 
+    /// Constructs a new [`Command`] for launching subsystem `program` on the remote
+    /// host.
+    ///
+    /// Unlike [`command`](Session::command), this method does not shell-escape `program`, so it may be evaluated in
+    /// unforeseen ways by the remote shell.
+    ///
+    /// The returned `Command` is a builder, with the following default configuration:
+    ///
+    /// * No arguments to the program
+    /// * Empty stdin and dsicard stdout/stderr for `spawn` or `status`, but create output pipes for
+    ///   `output`
+    ///
+    /// Builder methods are provided to change these defaults and otherwise configure the process.
+    ///
+    /// ## Sftp subsystem
+    ///
+    /// To use the sftp subsystem, you'll want to use [`openssh-sftp-client`],
+    /// then use the following code to construct a sftp instance:
+    ///
+    /// [`openssh-sftp-client`]: https://crates.io/crates/openssh-sftp-client
+    ///
+    /// ```rust,no_run
+    /// # use std::error::Error;
+    /// # #[cfg(feature = "native-mux")]
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn Error>> {
+    ///
+    /// use openssh::{Session, KnownHosts, Stdio};
+    /// use openssh_sftp_client::highlevel::Sftp;
+    ///
+    /// let session = Session::connect_mux("me@ssh.example.com", KnownHosts::Strict).await?;
+    ///
+    /// let mut child = session
+    ///     .subsystem("sftp")
+    ///     .stdin(Stdio::piped())
+    ///     .stdout(Stdio::piped())
+    ///     .spawn()
+    ///     .await?;
+    ///
+    /// Sftp::new(
+    ///     child.stdin().take().unwrap(),
+    ///     child.stdout().take().unwrap(),
+    ///     Default::default(),
+    /// )
+    /// .await?
+    /// .close()
+    /// .await?;
+    ///
+    /// # Ok(()) }
+    /// ```
+    pub fn subsystem<S: AsRef<OsStr>>(&self, program: S) -> Command<'_> {
+        Command::new(
+            self,
+            delegate!(&self.0, imp, { imp.subsystem(program).into() }),
+        )
+    }
+
     /// Constructs a new [`Command`] that runs the provided shell command on the remote host.
     ///
     /// The provided command is passed as a single, escaped argument to `sh -c`, and from that

tests/openssh.rs

@@ -828,3 +828,40 @@ async fn local_socket_forward() {
         assert!(output.status.success());
     }
 }
+
+#[tokio::test]
+#[cfg_attr(not(ci), ignore)]
+async fn test_sftp_subsystem() {
+    use openssh_sftp_client::highlevel::Sftp;
+
+    let content = b"This is a test case for the openssh-rust/openssh crate.\n";
+
+    for session in connects().await {
+        let mut child = session
+            .subsystem("sftp")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .await
+            .unwrap();
+
+        let sftp = Sftp::new(
+            child.stdin().take().unwrap(),
+            child.stdout().take().unwrap(),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+
+        let file_path = "/tmp/openssh-rust-test-sftp-subsystem";
+
+        {
+            let mut fs = sftp.fs();
+
+            fs.write(file_path, content).await.unwrap();
+            assert_eq!(&*sftp.fs().read(file_path).await.unwrap(), content);
+        }
+
+        sftp.close().await.unwrap();
+    }
+}