Add cli mode parsing support

distant-core/src/protocol/permissions.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 use bitflags::bitflags;
 use ignore::types::TypesBuilder;
 use ignore::WalkBuilder;
+use log::*;
 use serde::{Deserialize, Serialize};
 
 const MAXIMUM_THREADS: usize = 12;
@@ -93,6 +94,23 @@ impl Permissions {
                     std_permissions.set_mode(current.into());
                 }
 
+                if log_enabled!(Level::Trace) {
+                    let mut output = String::new();
+                    output.push_str("readonly = ");
+                    output.push_str(if std_permissions.readonly() {
+                        "true"
+                    } else {
+                        "false"
+                    });
+
+                    #[cfg(unix)]
+                    {
+                        use std::os::unix::prelude::*;
+                        output.push_str(&format!(", mode = {:#o}", std_permissions.mode()));
+                    }
+
+                    trace!("Setting {:?} permissions to ({})", $path, output);
+                }
                 tokio::fs::set_permissions($path, std_permissions).await?;
             }};
         }

src/cli/commands/client.rs

@@ -1033,11 +1033,19 @@ async fn async_run(cmd: ClientSubcommand) -> CliResult {
                     readonly,
                     unix: {
                         if readonly.is_none() {
-                            let mut new_mode = file_mode::Mode::empty();
-                            new_mode
-                                .set_str(&mode)
-                                .context("Failed to parse mode string")?;
-                            Some(UnixPermissions::from(new_mode.mode()))
+                            // Attempt to parse an octal number (chmod absolute), falling back to
+                            // parsing the mode string similar to chmod's symbolic mode
+                            let mode = match u32::from_str_radix(&mode, 8) {
+                                Ok(absolute) => file_mode::Mode::from(absolute),
+                                Err(_) => {
+                                    let mut new_mode = file_mode::Mode::empty();
+                                    new_mode
+                                        .set_str(&mode)
+                                        .context("Failed to parse mode string")?;
+                                    new_mode
+                                }
+                            };
+                            Some(UnixPermissions::from(mode.mode()))
                         } else {
                             None
                         }
@@ -1066,7 +1074,7 @@ async fn async_run(cmd: ClientSubcommand) -> CliResult {
                 recursive,
                 resolve_symlink: follow_symlinks,
             };
-            debug!("Setting permissions for {path:?} as (mode = {mode}, options = {options:?})");
+            debug!("Setting permissions for {path:?} as (permissions = {permissions:?}, options = {options:?})");
             channel
                 .into_client()
                 .into_channel()