Add support on windows

.github/workflows/os-check.yml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest]
+        os: [macos-latest, windows-latest]
     steps:
       - uses: actions-rs/toolchain@v1
         with:

Cargo.toml

@@ -36,23 +36,39 @@ process-mux = []
 native-mux = ["openssh-mux-client"]
 
 [dependencies]
-tempfile = "3.1.0"
 shell-escape = "0.1.5"
 tokio = { version = "1", features = [ "process", "io-util", "macros" ] }
-tokio-pipe = "0.2.8"
 
+[target.'cfg(unix)'.dependencies]
+# tempfile is used on unix to create tempdir for control socket
+tempfile = "3.1.0"
+
+# dirs is used on unix to decide the default prefix for tempdir
+dirs = "4.0.0"
+
+# libc is used on unix for function `dup`
 libc = "0.2.112"
-io-lifetimes = "0.5"
 
+# once_cell is used on unix to cache the default prefix for tempdir
+# and used in feature `native-mux` to cache `/dev/null` fd.
 once_cell = "1.8.0"
-dirs = "4.0.0"
+
+# io-lifetime is used on unix to store fd in `Stdio`
+io-lifetimes = "0.5"
+
+# tokio-pipe is used on unix to provide `ChildStdin`, `ChildStdout` and `ChildStderr`.
+tokio-pipe = "0.2.8"
 
 openssh-mux-client = { version = "0.14.4", optional = true }
 
+[target.'cfg(not(unix))'.dependencies]
+openssh-mux-client = { package = "blank", version = "0.1.0", optional = true }
+
 [dev-dependencies]
 lazy_static = "1.4.0"
 regex = "1"
 tokio = { version = "1", features = [ "full" ] }
+tempfile = "3.1.0"
 
 [[example]]
 name = "native-mux_tsp"

examples/native-mux_tsp.rs

@@ -1,6 +1,12 @@
+#[cfg(unix)]
 use openssh::*;
 
 #[tokio::main]
+#[cfg(windows)]
+async fn main() {}
+
+#[tokio::main]
+#[cfg(unix)]
 async fn main() {
     let session = Session::connect_mux("ssh://[email protected]:222", KnownHosts::Strict)
         .await

src/builder.rs

@@ -3,23 +3,31 @@ use super::{Error, Session};
 #[cfg(feature = "process-mux")]
 use super::process_impl;
 
-#[cfg(feature = "native-mux")]
+#[cfg(all(feature = "native-mux", unix))]
 use super::native_mux_impl;
 
 use std::borrow::Cow;
 use std::ffi::OsString;
-use std::fs;
 use std::path::{Path, PathBuf};
-use std::process::Stdio;
 use std::str;
 
-use dirs::state_dir;
-use once_cell::sync::OnceCell;
-use tempfile::{Builder, TempDir};
 use tokio::process;
 
+#[cfg(unix)]
+use std::fs;
+
+#[cfg(unix)]
+use std::process::Stdio;
+
+#[cfg(unix)]
+use tempfile::{Builder, TempDir};
+
 /// The returned `&'static Path` can be coreced to any lifetime.
+#[cfg(unix)]
 fn get_default_control_dir<'a>() -> Result<&'a Path, Error> {
+    use dirs::state_dir;
+    use once_cell::sync::OnceCell;
+
     static DEFAULT_CONTROL_DIR: OnceCell<Option<Box<Path>>> = OnceCell::new();
 
     DEFAULT_CONTROL_DIR
@@ -42,13 +50,15 @@ fn get_default_control_dir<'a>() -> Result<&'a Path, Error> {
 /// Build a [`Session`] with options.
 #[derive(Debug, Clone)]
 pub struct SessionBuilder {
+    #[cfg(unix)]
+    control_dir: Option<PathBuf>,
+
     user: Option<String>,
     port: Option<String>,
     keyfile: Option<PathBuf>,
     connect_timeout: Option<String>,
     server_alive_interval: Option<u64>,
     known_hosts_check: KnownHosts,
-    control_dir: Option<PathBuf>,
     config_file: Option<PathBuf>,
     compression: Option<bool>,
     user_known_hosts_file: Option<Box<Path>>,
@@ -57,13 +67,15 @@ pub struct SessionBuilder {
 impl Default for SessionBuilder {
     fn default() -> Self {
         Self {
+            #[cfg(unix)]
+            control_dir: None,
+
             user: None,
             port: None,
             keyfile: None,
             connect_timeout: None,
             server_alive_interval: None,
             known_hosts_check: KnownHosts::Add,
-            control_dir: None,
             config_file: None,
             compression: None,
             user_known_hosts_file: None,
@@ -187,8 +199,17 @@ impl SessionBuilder {
     pub async fn connect<S: AsRef<str>>(&self, destination: S) -> Result<Session, Error> {
         let destination = destination.as_ref();
         let (builder, destination) = self.resolve(destination);
-        let tempdir = builder.launch_master(destination).await?;
-        Ok(process_impl::Session::new(tempdir, destination).into())
+
+        #[cfg(unix)]
+        {
+            let tempdir = builder.launch_master(destination).await?;
+            Ok(process_impl::Session::new(tempdir, destination).into())
+        }
+
+        #[cfg(windows)]
+        {
+            Ok(process_impl::Session::new(builder.into_owned(), destination).into())
+        }
     }
 
     /// Connect to the host at the given `host` over SSH using native mux, which will
@@ -204,8 +225,8 @@ impl SessionBuilder {
     /// If connecting requires interactive authentication based on `STDIN` (such as reading a
     /// password), the connection will fail. Consider setting up keypair-based authentication
     /// instead.
-    #[cfg(feature = "native-mux")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "native-mux")))]
+    #[cfg(all(feature = "native-mux", unix))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "native-mux", unix))))]
     pub async fn connect_mux<S: AsRef<str>>(&self, destination: S) -> Result<Session, Error> {
         let destination = destination.as_ref();
         let (builder, destination) = self.resolve(destination);
@@ -251,77 +272,82 @@ impl SessionBuilder {
         (Cow::Owned(with_overrides), destination)
     }
 
-    async fn launch_master(&self, destination: &str) -> Result<TempDir, Error> {
-        let socketdir = if let Some(socketdir) = self.control_dir.as_ref() {
-            socketdir
-        } else {
-            get_default_control_dir()?
-        };
-
-        let dir = Builder::new()
-            .prefix(".ssh-connection")
-            .tempdir_in(socketdir)
-            .map_err(Error::Master)?;
-
-        let log = dir.path().join("log");
-
-        let mut init = process::Command::new("ssh");
-
-        init.stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .arg("-E")
-            .arg(&log)
-            .arg("-S")
-            .arg(dir.path().join("master"))
-            .arg("-M")
-            .arg("-f")
-            .arg("-N")
-            .arg("-o")
-            .arg("ControlPersist=yes")
-            .arg("-o")
-            .arg("BatchMode=yes")
-            .arg("-o")
-            .arg(self.known_hosts_check.as_option());
+    pub(crate) fn apply_options(&self, cmd: &mut process::Command) {
+        cmd.arg("-o").arg(self.known_hosts_check.as_option());
 
         if let Some(ref timeout) = self.connect_timeout {
-            init.arg("-o").arg(format!("ConnectTimeout={}", timeout));
+            cmd.arg("-o").arg(format!("ConnectTimeout={}", timeout));
         }
 
         if let Some(ref interval) = self.server_alive_interval {
-            init.arg("-o")
+            cmd.arg("-o")
                 .arg(format!("ServerAliveInterval={}", interval));
         }
 
         if let Some(ref port) = self.port {
-            init.arg("-p").arg(port);
+            cmd.arg("-p").arg(port);
         }
 
         if let Some(ref user) = self.user {
-            init.arg("-l").arg(user);
+            cmd.arg("-l").arg(user);
         }
 
         if let Some(ref k) = self.keyfile {
             // if the user gives a keyfile, _only_ use that keyfile
-            init.arg("-o").arg("IdentitiesOnly=yes");
-            init.arg("-i").arg(k);
+            cmd.arg("-o").arg("IdentitiesOnly=yes");
+            cmd.arg("-i").arg(k);
         }
 
         if let Some(ref config_file) = self.config_file {
-            init.arg("-F").arg(config_file);
+            cmd.arg("-F").arg(config_file);
         }
 
         if let Some(compression) = self.compression {
             let arg = if compression { "yes" } else { "no" };
 
-            init.arg("-o").arg(format!("Compression={}", arg));
+            cmd.arg("-o").arg(format!("Compression={}", arg));
         }
 
         if let Some(user_known_hosts_file) = &self.user_known_hosts_file {
             let mut option: OsString = "UserKnownHostsFile=".into();
             option.push(&**user_known_hosts_file);
-            init.arg("-o").arg(option);
+            cmd.arg("-o").arg(option);
         }
+    }
+
+    #[cfg(not(windows))]
+    async fn launch_master(&self, destination: &str) -> Result<TempDir, Error> {
+        let socketdir = if let Some(socketdir) = self.control_dir.as_ref() {
+            socketdir
+        } else {
+            get_default_control_dir()?
+        };
+
+        let dir = Builder::new()
+            .prefix(".ssh-connection")
+            .tempdir_in(socketdir)
+            .map_err(Error::Master)?;
+
+        let log = dir.path().join("log");
+
+        let mut init = process::Command::new("ssh");
+
+        init.stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .arg("-E")
+            .arg(&log)
+            .arg("-S")
+            .arg(dir.path().join("master"))
+            .arg("-M")
+            .arg("-f")
+            .arg("-N")
+            .arg("-o")
+            .arg("ControlPersist=yes")
+            .arg("-o")
+            .arg("BatchMode=yes");
+
+        self.apply_options(&mut init);
 
         init.arg(destination);
 

src/child.rs

@@ -11,7 +11,7 @@ pub(crate) enum RemoteChildImp {
     #[cfg(feature = "process-mux")]
     ProcessImpl(super::process_impl::RemoteChild),
 
-    #[cfg(feature = "native-mux")]
+    #[cfg(all(feature = "native-mux", unix))]
     NativeMuxImpl(super::native_mux_impl::RemoteChild),
 }
 #[cfg(feature = "process-mux")]
@@ -21,7 +21,7 @@ impl From<super::process_impl::RemoteChild> for RemoteChildImp {
     }
 }
 
-#[cfg(feature = "native-mux")]
+#[cfg(all(feature = "native-mux", unix))]
 impl From<super::native_mux_impl::RemoteChild> for RemoteChildImp {
     fn from(imp: super::native_mux_impl::RemoteChild) -> Self {
         RemoteChildImp::NativeMuxImpl(imp)
@@ -34,7 +34,7 @@ macro_rules! delegate {
             #[cfg(feature = "process-mux")]
             RemoteChildImp::ProcessImpl($var) => $then,
 
-            #[cfg(feature = "native-mux")]
+            #[cfg(all(feature = "native-mux", unix))]
             RemoteChildImp::NativeMuxImpl($var) => $then,
         }
     }};

src/command.rs

@@ -12,7 +12,7 @@ pub(crate) enum CommandImp {
     #[cfg(feature = "process-mux")]
     ProcessImpl(super::process_impl::Command),
 
-    #[cfg(feature = "native-mux")]
+    #[cfg(all(feature = "native-mux", unix))]
     NativeMuxImpl(super::native_mux_impl::Command),
 }
 #[cfg(feature = "process-mux")]
@@ -22,7 +22,7 @@ impl From<super::process_impl::Command> for CommandImp {
     }
 }
 
-#[cfg(feature = "native-mux")]
+#[cfg(all(feature = "native-mux", unix))]
 impl<'s> From<super::native_mux_impl::Command> for CommandImp {
     fn from(imp: super::native_mux_impl::Command) -> Self {
         CommandImp::NativeMuxImpl(imp)
@@ -36,13 +36,13 @@ macro_rules! delegate {
             #[cfg(feature = "process-mux")]
             CommandImp::ProcessImpl($var) => $then,
 
-            #[cfg(feature = "native-mux")]
+            #[cfg(all(feature = "native-mux", unix))]
             CommandImp::NativeMuxImpl($var) => $then,
         }
     }};
 }
 
-#[cfg(not(any(feature = "process-mux", feature = "native-mux")))]
+#[cfg(not(any(feature = "process-mux", all(feature = "native-mux", unix))))]
 macro_rules! delegate {
     ($impl:expr, $var:ident, $then:block) => {{
         unreachable!("Neither feature process-mux nor native-mux is enabled")