more fixe

Author: sylvestre

src/uu/rm/src/platform/linux.rs

@@ -0,0 +1,258 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Linux-specific implementations for the rm utility
+
+use std::fs;
+use std::path::Path;
+use uucore::display::Quotable;
+use uucore::error::FromIo;
+use uucore::safe_traversal::DirFd;
+use uucore::show_error;
+use uucore::translate;
+
+use super::super::{
+    InteractiveMode, Options, is_dir_empty, is_readable_metadata, prompt_descend, prompt_dir,
+    prompt_file, remove_file, show_permission_denied_error, show_removal_error,
+    verbose_removed_directory, verbose_removed_file,
+};
+
+/// Whether the given file or directory is readable.
+pub fn is_readable(path: &Path) -> bool {
+    match fs::metadata(path) {
+        Err(_) => false,
+        Ok(metadata) => is_readable_metadata(&metadata),
+    }
+}
+
+/// Helper function to remove directory handling special cases
+pub fn remove_dir_with_special_cases(path: &Path, options: &Options, error_occurred: bool) -> bool {
+    match fs::remove_dir(path) {
+        Err(_) if !error_occurred && !is_readable(path) => {
+            // For compatibility with GNU test case
+            // `tests/rm/unread2.sh`, show "Permission denied" in this
+            // case instead of "Directory not empty".
+            show_permission_denied_error(path);
+            true
+        }
+        Err(_) if !error_occurred && path.read_dir().is_err() => {
+            // For compatibility with GNU test case on Linux
+            // Check if directory is readable by attempting to read it
+            show_permission_denied_error(path);
+            true
+        }
+        Err(e) if !error_occurred => {
+            // Check if directory is readable - if not, show permission denied
+            // for compatibility with GNU rm behavior
+            if is_readable(path) {
+                show_removal_error(e, path)
+            } else {
+                show_permission_denied_error(path);
+                true
+            }
+        }
+        Err(_) => {
+            // If we already had errors while
+            // trying to remove the children, then there is no need to
+            // show another error message as we return from each level
+            // of the recursion.
+            error_occurred
+        }
+        Ok(_) => {
+            verbose_removed_directory(path, options);
+            false
+        }
+    }
+}
+
+pub fn safe_remove_dir_recursive(path: &Path, options: &Options) -> bool {
+    // Base case 1: this is a file or a symbolic link.
+    if !path.is_dir() || path.is_symlink() {
+        return remove_file(path, options);
+    }
+
+    // Try to open the directory using DirFd for secure traversal
+    let dir_fd = match DirFd::open(path) {
+        Ok(fd) => fd,
+        Err(e) => {
+            // If we can't open the directory for safe traversal,
+            // handle the error appropriately and try to remove if possible
+            if e.kind() == std::io::ErrorKind::PermissionDenied {
+                // Try to remove the directory directly if it's empty
+                match fs::remove_dir(path) {
+                    Ok(_) => {
+                        verbose_removed_directory(path, options);
+                        return false;
+                    }
+                    Err(_remove_err) => {
+                        // If we can't read the directory AND can't remove it,
+                        // show permission denied error for GNU compatibility
+                        return show_permission_denied_error(path);
+                    }
+                }
+            }
+            return show_removal_error(e, path);
+        }
+    };
+
+    let error = safe_remove_dir_recursive_impl(path, &dir_fd, options);
+
+    // After processing all children, remove the directory itself
+    if error {
+        error
+    } else {
+        // Ask user permission if needed
+        if options.interactive == InteractiveMode::Always && !prompt_dir(path, options) {
+            return false;
+        }
+
+        // Before trying to remove the directory, check if it's actually empty
+        // This handles the case where some children weren't removed due to user "no" responses
+        if !is_dir_empty(path) {
+            // Directory is not empty, so we can't/shouldn't remove it
+            // In interactive mode, this might be expected if user said "no" to some children
+            // In non-interactive mode, this indicates an error (some children couldn't be removed)
+            if options.interactive == InteractiveMode::Always {
+                return false;
+            }
+            // Try to remove the directory anyway and let the system tell us why it failed
+            // Use false for error_occurred since this is the main error we want to report
+            return remove_dir_with_special_cases(path, options, false);
+        }
+
+        // Directory is empty and user approved removal
+        remove_dir_with_special_cases(path, options, error)
+    }
+}
+
+pub fn safe_remove_dir_recursive_impl(path: &Path, dir_fd: &DirFd, options: &Options) -> bool {
+    // Read directory entries using safe traversal
+    let entries = match dir_fd.read_dir() {
+        Ok(entries) => entries,
+        Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+            // This is not considered an error - just like the original
+            return false;
+        }
+        Err(e) => {
+            if !options.force {
+                show_error!(
+                    "{}",
+                    e.map_err_context(
+                        || translate!("rm-error-cannot-remove", "file" => path.quote())
+                    )
+                );
+            }
+            return !options.force;
+        }
+    };
+
+    let mut error = false;
+
+    // Process each entry
+    for entry_name in entries {
+        let entry_path = path.join(&entry_name);
+
+        // Get metadata for the entry using fstatat
+        let entry_stat = match dir_fd.stat_at(&entry_name, false) {
+            Ok(stat) => stat,
+            Err(e) => {
+                if !options.force {
+                    let e = e.map_err_context(
+                        || translate!("rm-error-cannot-remove", "file" => entry_path.quote()),
+                    );
+                    show_error!("{e}");
+                }
+                error = !options.force;
+                continue;
+            }
+        };
+
+        // Check if it's a directory
+        let is_dir = (entry_stat.st_mode & libc::S_IFMT) == libc::S_IFDIR;
+
+        if is_dir {
+            // Ask user if they want to descend into this directory
+            if options.interactive == InteractiveMode::Always
+                && !is_dir_empty(&entry_path)
+                && !prompt_descend(&entry_path)
+            {
+                continue;
+            }
+
+            // Recursively remove subdirectory using safe traversal
+            let child_dir_fd = match dir_fd.open_subdir(&entry_name) {
+                Ok(fd) => fd,
+                Err(e) => {
+                    // If we can't open the subdirectory for safe traversal,
+                    // try to handle it as best we can with safe operations
+                    if e.kind() == std::io::ErrorKind::PermissionDenied {
+                        // For permission denied, try to remove the directory directly
+                        // if it's empty, or show appropriate error
+                        if let Err(remove_err) = dir_fd.unlink_at(&entry_name, true) {
+                            if !options.force {
+                                let remove_err = remove_err.map_err_context(
+                                    || translate!("rm-error-cannot-remove", "file" => entry_path.quote()),
+                                );
+                                show_error!("{remove_err}");
+                            }
+                            error = !options.force;
+                        } else {
+                            verbose_removed_directory(&entry_path, options);
+                        }
+                    } else {
+                        // For other errors, report and continue
+                        if !options.force {
+                            let e = e.map_err_context(
+                                || translate!("rm-error-cannot-remove", "file" => entry_path.quote()),
+                            );
+                            show_error!("{e}");
+                        }
+                        error = !options.force;
+                    }
+                    continue;
+                }
+            };
+
+            let child_error = safe_remove_dir_recursive_impl(&entry_path, &child_dir_fd, options);
+            error = error || child_error;
+
+            // Ask user permission if needed for this subdirectory
+            if !child_error
+                && options.interactive == InteractiveMode::Always
+                && !prompt_dir(&entry_path, options)
+            {
+                continue;
+            }
+
+            // Remove the now-empty subdirectory using safe unlinkat
+            if !child_error {
+                if let Err(e) = dir_fd.unlink_at(&entry_name, true) {
+                    let e = e.map_err_context(
+                        || translate!("rm-error-cannot-remove", "file" => entry_path.quote()),
+                    );
+                    show_error!("{e}");
+                    error = true;
+                } else {
+                    verbose_removed_directory(&entry_path, options);
+                }
+            }
+        } else {
+            // Remove file - check if user wants to remove it first
+            if prompt_file(&entry_path, options) {
+                if let Err(e) = dir_fd.unlink_at(&entry_name, false) {
+                    let e = e.map_err_context(
+                        || translate!("rm-error-cannot-remove", "file" => entry_path.quote()),
+                    );
+                    show_error!("{e}");
+                    error = true;
+                } else {
+                    verbose_removed_file(&entry_path, options);
+                }
+            }
+        }
+    }
+
+    error
+}