readlink: implement -f

Author: andrewliebenow

tree/readlink.rs

@@ -9,9 +9,14 @@
 
 use clap::Parser;
 use gettextrs::{bind_textdomain_codeset, setlocale, textdomain, LocaleCategory};
+use std::collections::HashSet;
+use std::error::Error;
+use std::ffi::OsString;
+use std::fs;
 use std::io::Write;
+use std::io::{stderr, stdout, ErrorKind};
 use std::path::PathBuf;
-use std::{fs, io};
+use std::path::{Component, Path};
 
 /// readlink — display the contents of a symbolic link
 #[derive(Parser)]
@@ -21,33 +26,143 @@ struct Args {
     #[arg(short, long)]
     no_newline: bool,
 
+    // Not POSIX, but implemented by BusyBox, FreeBSD, GNU Core Utilities, toybox, and others
+    /// Canonicalize the provided path, resolving symbolic links repeatedly if needed. The absolute path of the resolved file is printed.
+    #[arg(short = 'f')]
+    canonicalize: bool,
+
     /// The pathname of an existing symbolic link
     pathname: PathBuf,
 }
 
-fn do_readlink(args: &Args) -> Result<String, String> {
-    let path = PathBuf::from(&args.pathname);
+// Behavior of "readlink -f /existent-directory/non-existent-file" varies
+// Most implementations: print hypothetical fully resolved absolute path, exit code 0
+// bsdutils/FreeBSD, toybox: print nothing, exit code 1
+//
+// Behavior of "readlink -f /non-existent-directory/non-existent-file" does not vary
+// All implementations: print nothing, exit code 1
+fn do_readlink(args: Args) -> Result<String, String> {
+    // TODO
+    // Add --verbose option and mirror other implementations (which are quiet by default)?
+    let verbose = true;
+
+    let Args {
+        no_newline,
+        canonicalize,
+        pathname,
+    } = args;
+
+    let pathname_path = pathname.as_path();
+
+    let format_error = |description: &str, error: Option<&dyn Error>| {
+        let pathname_path_display = pathname_path.display();
+
+        let st = if let Some(er) = error {
+            format!("{pathname_path_display}: {description}: {er}")
+        } else {
+            format!("{pathname_path_display}: {description}")
+        };
 
-    match fs::read_link(&path) {
-        Ok(target) => {
-            let output = target.display().to_string();
-            if args.no_newline {
-                Ok(output)
-            } else {
-                Ok(output + "\n")
+        Result::<String, String>::Err(st)
+    };
+
+    let format_returned_path = |path_to_return: &Path| {
+        let path_to_return_display = path_to_return.display();
+
+        let st = if no_newline {
+            format!("{path_to_return_display}")
+        } else {
+            format!("{path_to_return_display}\n")
+        };
+
+        Result::<String, String>::Ok(st)
+    };
+
+    let map_io_error = |error: &std::io::Error| {
+        match error.kind() {
+            ErrorKind::NotFound => {
+                // All or almost all other implementations do not print an error here
+                // (but they do exit with exit code 1)
+                if verbose {
+                    format_error("No such file or directory", None)
+                } else {
+                    Err(String::new())
+                }
             }
+            ErrorKind::PermissionDenied => {
+                if verbose {
+                    format_error("Permission denied", None)
+                } else {
+                    Err(String::new())
+                }
+            }
+            _ => format_error("Unknown error", Some(&error)),
         }
-        Err(e) => {
-            let err_message = match e.kind() {
-                io::ErrorKind::NotFound => {
-                    format!("readlink: {}: No such file or directory\n", path.display())
+    };
+
+    if canonicalize {
+        let recursively_resolved_path_buf = recursive_resolve(pathname_path.to_owned())?;
+
+        match fs::canonicalize(recursively_resolved_path_buf.as_path()) {
+            Ok(pa) => format_returned_path(pa.as_path()),
+            Err(er) => {
+                let mut components = recursively_resolved_path_buf.components();
+
+                // Check if the last component of the path is a "normal" component
+                // (e.g. "normal-component" in "/prefix/normal-component/suffix")
+                //
+                // If so, the fallback path (since the path itself could not be canonicalized)
+                // is to canonicalize the parent directory path, and append the last path component
+                if let Some(Component::Normal(last_component)) = components.next_back() {
+                    let parent_path = components.as_path();
+
+                    match fs::canonicalize(parent_path) {
+                        Ok(parent_path_canonicalized) => {
+                            // Before printing the hypothetical resolved path:
+                            // ensure that the parent is actually a directory
+                            if !parent_path_canonicalized.is_dir() {
+                                return format_error("Not a directory", None);
+                            }
+
+                            let parent_path_canonicalized_with_last_component = {
+                                let mut pa = parent_path_canonicalized;
+
+                                pa.push(last_component);
+
+                                pa
+                            };
+
+                            format_returned_path(
+                                parent_path_canonicalized_with_last_component.as_path(),
+                            )
+                        }
+                        Err(err) => map_io_error(&err),
+                    }
+                } else {
+                    map_io_error(&er)
                 }
-                io::ErrorKind::InvalidInput => {
-                    format!("readlink: {}: Not a symbolic link\n", path.display())
+            }
+        }
+    } else {
+        match fs::symlink_metadata(pathname_path) {
+            Ok(me) => {
+                if !me.is_symlink() {
+                    // POSIX says:
+                    // "If file does not name a symbolic link, readlink shall write a diagnostic message to standard error and exit with non-zero status."
+                    // However, this is violated by almost all implementations
+                    return if verbose {
+                        format_error("Not a symbolic link", None)
+                    } else {
+                        Err(String::new())
+                    };
                 }
-                _ => format!("readlink: {}: {}\n", path.display(), e),
-            };
-            Err(err_message)
+
+                match fs::read_link(pathname_path) {
+                    Ok(pa) => format_returned_path(pa.as_path()),
+                    Err(er) => map_io_error(&er),
+                }
+            }
+            Err(er) => map_io_error(&er),
         }
     }
 }
@@ -59,19 +174,53 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let args = Args::parse();
 
-    let mut exit_code = 0;
-
-    match do_readlink(&args) {
+    let exit_code = match do_readlink(args) {
         Ok(output) => {
-            print!("{}", output);
-            io::stdout().flush().unwrap();
+            let mut stdout_lock = stdout().lock();
+
+            write!(stdout_lock, "{output}").unwrap();
+
+            stdout_lock.flush().unwrap();
+
+            0_i32
         }
-        Err(err) => {
-            eprint!("{}", err);
-            io::stderr().flush().unwrap();
-            exit_code = 1;
+        Err(error_description) => {
+            let mut stderr_lock = stderr().lock();
+
+            writeln!(&mut stderr_lock, "readlink: {error_description}").unwrap();
+
+            stderr_lock.flush().unwrap();
+
+            1_i32
         }
-    }
+    };
 
     std::process::exit(exit_code);
 }
+
+fn recursive_resolve(starting_path_buf: PathBuf) -> Result<PathBuf, String> {
+    let mut current_path_buf = starting_path_buf;
+
+    let mut encountered_paths = HashSet::<OsString>::new();
+
+    #[allow(clippy::while_let_loop)]
+    loop {
+        match fs::read_link(current_path_buf.as_path()) {
+            Ok(pa) => {
+                if !encountered_paths.insert(pa.as_os_str().to_owned()) {
+                    return Err(format!(
+                        "Infinite symbolic link loop detected at \"{}\")",
+                        pa.to_string_lossy()
+                    ));
+                }
+
+                current_path_buf = pa;
+            }
+            Err(_) => {
+                break;
+            }
+        }
+    }
+
+    Ok(current_path_buf)
+}