Tricky-copy in case copy is not supported

src/ui/activities/filetransfer/actions/copy.rs

@@ -25,8 +25,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+extern crate tempfile;
 // locals
 use super::{FileTransferActivity, FsEntry, LogLevel, SelectedEntry};
+use crate::filetransfer::FileTransferErrorType;
 use std::path::{Path, PathBuf};
 
 impl FileTransferActivity {
@@ -120,15 +122,21 @@ impl FileTransferActivity {
                     ),
                 );
             }
-            Err(err) => self.log_and_alert(
-                LogLevel::Error,
-                format!(
-                    "Could not copy \"{}\" to \"{}\": {}",
-                    entry.get_abs_path().display(),
-                    dest.display(),
-                    err
+            Err(err) => match err.kind() {
+                FileTransferErrorType::UnsupportedFeature => {
+                    // If copy is not supported, perform the tricky copy
+                    self.tricky_copy(entry, dest);
+                }
+                _ => self.log_and_alert(
+                    LogLevel::Error,
+                    format!(
+                        "Could not copy \"{}\" to \"{}\": {}",
+                        entry.get_abs_path().display(),
+                        dest.display(),
+                        err
+                    ),
                 ),
-            ),
+            },
         }
     }
 }

src/ui/activities/filetransfer/session.rs

@@ -899,4 +899,110 @@ impl FileTransferActivity {
         }
         Ok(())
     }
+
+    /// ### tricky_copy
+    ///
+    /// Tricky copy will be used whenever copy command is not available on remote host
+    pub(super) fn tricky_copy(&mut self, entry: &FsEntry, dest: &Path) {
+        // match entry
+        match entry {
+            FsEntry::File(entry) => {
+                // Create tempfile
+                let tmpfile: tempfile::NamedTempFile = match tempfile::NamedTempFile::new() {
+                    Ok(f) => f,
+                    Err(err) => {
+                        self.log_and_alert(
+                            LogLevel::Error,
+                            format!("Copy failed: could not create temporary file: {}", err),
+                        );
+                        return;
+                    }
+                };
+                // Download file
+                if let Err(err) =
+                    self.filetransfer_recv_file(tmpfile.path(), entry, entry.name.clone())
+                {
+                    self.log_and_alert(
+                        LogLevel::Error,
+                        format!("Copy failed: could not download to temporary file: {}", err),
+                    );
+                    return;
+                }
+                // Get local fs entry
+                let tmpfile_entry: FsEntry = match self.host.stat(tmpfile.path()) {
+                    Ok(e) => e,
+                    Err(err) => {
+                        self.log_and_alert(
+                            LogLevel::Error,
+                            format!(
+                                "Copy failed: could not stat \"{}\": {}",
+                                tmpfile.path().display(),
+                                err
+                            ),
+                        );
+                        return;
+                    }
+                };
+                let tmpfile_entry = match &tmpfile_entry {
+                    FsEntry::Directory(_) => panic!("tempfile is a directory for some reason"),
+                    FsEntry::File(f) => f,
+                };
+                // Upload file to destination
+                if let Err(err) = self.filetransfer_send_file(
+                    tmpfile_entry,
+                    dest,
+                    String::from(dest.to_string_lossy()),
+                ) {
+                    self.log_and_alert(
+                        LogLevel::Error,
+                        format!(
+                            "Copy failed: could not write file {}: {}",
+                            entry.abs_path.display(),
+                            err
+                        ),
+                    );
+                    return;
+                }
+            }
+            FsEntry::Directory(_) => {
+                let tempdir: tempfile::TempDir = match tempfile::TempDir::new() {
+                    Ok(d) => d,
+                    Err(err) => {
+                        self.log_and_alert(
+                            LogLevel::Error,
+                            format!("Copy failed: could not create temporary directory: {}", err),
+                        );
+                        return;
+                    }
+                };
+                // Download file
+                self.filetransfer_recv(entry, tempdir.path(), None);
+                // Get path of dest
+                let mut tempdir_path: PathBuf = tempdir.path().to_path_buf();
+                tempdir_path.push(entry.get_name());
+                // Stat dir
+                let tempdir_entry: FsEntry = match self.host.stat(tempdir_path.as_path()) {
+                    Ok(e) => e,
+                    Err(err) => {
+                        self.log_and_alert(
+                            LogLevel::Error,
+                            format!(
+                                "Copy failed: could not stat \"{}\": {}",
+                                tempdir.path().display(),
+                                err
+                            ),
+                        );
+                        return;
+                    }
+                };
+                // Upload to destination
+                let wrkdir: PathBuf = self.remote().wrkdir.clone();
+                self.filetransfer_send(
+                    &tempdir_entry,
+                    wrkdir.as_path(),
+                    Some(String::from(dest.to_string_lossy())),
+                );
+            }
+        }
+    }
 }

src/ui/activities/filetransfer/view.rs

@@ -456,7 +456,7 @@ impl FileTransferActivity {
             Box::new(Input::new(
                 InputPropsBuilder::default()
                     .with_borders(Borders::ALL, BorderType::Rounded, Color::White)
-                    .with_label(String::from("Insert destination name"))
+                    .with_label(String::from("Copy file(s) to..."))
                     .build(),
             )),
         );
@@ -586,7 +586,7 @@ impl FileTransferActivity {
             Box::new(Input::new(
                 InputPropsBuilder::default()
                     .with_borders(Borders::ALL, BorderType::Rounded, Color::White)
-                    .with_label(String::from("Insert new name"))
+                    .with_label(String::from("Move file(s) to..."))
                     .build(),
             )),
         );