Merge branch 'uutils:main' into sort/sort-merge-fdlimit.sh

Author: mattsu2020

Cargo.toml

@@ -667,7 +667,6 @@ should_panic_without_expect = "allow"        # 2
 doc_markdown = "allow"
 unused_self = "allow"
 enum_glob_use = "allow"
-needless_raw_string_hashes = "allow"
 unreadable_literal = "allow"
 unnested_or_patterns = "allow"
 implicit_hasher = "allow"

src/uu/env/src/env.rs

@@ -24,13 +24,13 @@ use nix::sys::signal::{SigHandler::SigIgn, Signal, signal};
 use std::borrow::Cow;
 use std::env;
 use std::ffi::{OsStr, OsString};
-use std::io::{self, Write};
+use std::io;
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
 #[cfg(unix)]
 use std::os::unix::process::CommandExt;
 
-use uucore::display::{OsWrite, Quotable};
+use uucore::display::{Quotable, print_all_env_vars};
 use uucore::error::{ExitCode, UError, UResult, USimpleError, UUsageError};
 use uucore::line_ending::LineEnding;
 #[cfg(unix)]
@@ -99,19 +99,6 @@ struct Options<'a> {
     ignore_signal: Vec<usize>,
 }
 
-/// print `name=value` env pairs on screen
-fn print_env(line_ending: LineEnding) -> io::Result<()> {
-    let stdout_raw = io::stdout();
-    let mut stdout = stdout_raw.lock();
-    for (n, v) in env::vars_os() {
-        stdout.write_all_os(&n)?;
-        stdout.write_all(b"=")?;
-        stdout.write_all_os(&v)?;
-        write!(stdout, "{line_ending}")?;
-    }
-    Ok(())
-}
-
 fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<bool> {
     // is it a NAME=VALUE like opt ?
     let wrap = NativeStr::<'a>::new(opt);
@@ -552,7 +539,7 @@ impl EnvAppData {
 
         if opts.program.is_empty() {
             // no program provided, so just dump all env vars to stdout
-            print_env(opts.line_ending)?;
+            print_all_env_vars(opts.line_ending)?;
         } else {
             return self.run_program(&opts, self.do_debug_printing);
         }

src/uu/printenv/src/printenv.rs

@@ -8,9 +8,10 @@ use std::io::Write;
 
 use clap::{Arg, ArgAction, Command};
 
+use uucore::display::{OsWrite, print_all_env_vars};
 use uucore::error::UResult;
 use uucore::line_ending::LineEnding;
-use uucore::{format_usage, os_str_as_bytes, translate};
+use uucore::{format_usage, translate};
 
 static OPT_NULL: &str = "null";
 
@@ -28,14 +29,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let separator = LineEnding::from_zero_flag(matches.get_flag(OPT_NULL));
 
     if variables.is_empty() {
-        for (env_var, value) in env::vars_os() {
-            let env_bytes = os_str_as_bytes(&env_var)?;
-            let val_bytes = os_str_as_bytes(&value)?;
-            std::io::stdout().lock().write_all(env_bytes)?;
-            print!("=");
-            std::io::stdout().lock().write_all(val_bytes)?;
-            print!("{separator}");
-        }
+        print_all_env_vars(separator)?;
         return Ok(());
     }
 
@@ -47,9 +41,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             continue;
         }
         if let Some(var) = env::var_os(env_var) {
-            let val_bytes = os_str_as_bytes(&var)?;
-            std::io::stdout().lock().write_all(val_bytes)?;
-            print!("{separator}");
+            let mut stdout = std::io::stdout().lock();
+            stdout.write_all_os(&var)?;
+            write!(stdout, "{separator}")?;
         } else {
             error_found = true;
         }

src/uu/runcon/src/runcon.rs

@@ -15,9 +15,10 @@ use uucore::format_usage;
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
-use std::os::raw::c_char;
+use std::io;
 use std::os::unix::ffi::OsStrExt;
-use std::{io, ptr};
+use std::os::unix::process::CommandExt;
+use std::process;
 
 mod errors;
 
@@ -367,23 +368,8 @@ fn get_custom_context(
 /// compiler the only valid return type is to say "if this returns, it will
 /// always return an error".
 fn execute_command(command: &OsStr, arguments: &[OsString]) -> UResult<()> {
-    let c_command = os_str_to_c_string(command).map_err(RunconError::new)?;
+    let err = process::Command::new(command).args(arguments).exec();
 
-    let argv_storage: Vec<CString> = arguments
-        .iter()
-        .map(AsRef::as_ref)
-        .map(os_str_to_c_string)
-        .collect::<Result<_>>()
-        .map_err(RunconError::new)?;
-
-    let mut argv: Vec<*const c_char> = Vec::with_capacity(arguments.len().saturating_add(2));
-    argv.push(c_command.as_ptr());
-    argv.extend(argv_storage.iter().map(AsRef::as_ref).map(CStr::as_ptr));
-    argv.push(ptr::null());
-
-    unsafe { libc::execvp(c_command.as_ptr(), argv.as_ptr()) };
-
-    let err = io::Error::last_os_error();
     let exit_status = if err.kind() == io::ErrorKind::NotFound {
         error_exit_status::NOT_FOUND
     } else {

src/uucore/build.rs

@@ -58,6 +58,11 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 /// Get the project root directory
+///
+/// # Errors
+///
+/// Returns an error if the `CARGO_MANIFEST_DIR` environment variable is not set
+/// or if the current directory structure does not allow determining the project root.
 fn project_root() -> Result<std::path::PathBuf, Box<dyn std::error::Error>> {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR")?;
     let uucore_path = std::path::Path::new(&manifest_dir);
@@ -120,6 +125,11 @@ fn detect_target_utility() -> Option<String> {
 }
 
 /// Embed locale for a single specific utility
+///
+/// # Errors
+///
+/// Returns an error if the locales for `util_name` or `uucore` cannot be found
+/// or if writing to the `embedded_file` fails.
 fn embed_single_utility_locale(
     embedded_file: &mut std::fs::File,
     project_root: &Path,
@@ -142,7 +152,12 @@ fn embed_single_utility_locale(
     Ok(())
 }
 
-/// Embed locale files for all utilities (multicall binary)
+/// Embed locale files for all utilities (multicall binary).
+///
+/// # Errors
+///
+/// Returns an error if the `src/uu` directory cannot be read, if any utility
+/// locales cannot be embedded, or if flushing the `embedded_file` fails.
 fn embed_all_utility_locales(
     embedded_file: &mut std::fs::File,
     project_root: &Path,
@@ -188,6 +203,12 @@ fn embed_all_utility_locales(
     Ok(())
 }
 
+/// Embed static utility locales for crates.io builds.
+///
+/// # Errors
+///
+/// Returns an error if the directory containing the crate cannot be read or
+/// if writing to the `embedded_file` fails.
 fn embed_static_utility_locales(
     embedded_file: &mut std::fs::File,
     locales_to_embed: &(String, Option<String>),
@@ -213,7 +234,7 @@ fn embed_static_utility_locales(
     let mut entries: Vec<_> = std::fs::read_dir(registry_dir)?
         .filter_map(Result::ok)
         .collect();
-    entries.sort_by_key(|e| e.file_name());
+    entries.sort_by_key(std::fs::DirEntry::file_name);
 
     for entry in entries {
         let file_name = entry.file_name();
@@ -256,6 +277,11 @@ fn get_locales_to_embed() -> (String, Option<String>) {
 }
 
 /// Helper function to iterate over the locales to embed.
+///
+/// # Errors
+///
+/// Returns an error if the provided closure `f` returns an error when called
+/// on either the primary or system locale.
 fn for_each_locale<F>(
     locales: &(String, Option<String>),
     mut f: F,
@@ -271,6 +297,11 @@ where
 }
 
 /// Helper function to embed a single locale file.
+///
+/// # Errors
+///
+/// Returns an error if the file at `locale_path` cannot be read or if
+/// writing to `embedded_file` fails.
 fn embed_locale_file(
     embedded_file: &mut std::fs::File,
     locale_path: &Path,
@@ -286,9 +317,11 @@ fn embed_locale_file(
             embedded_file,
             "        // Locale for {component} ({locale})"
         )?;
+        // Determine if we need a hash. If content contains ", we need r#""#
+        let delimiter = if content.contains('"') { "#" } else { "" };
         writeln!(
             embedded_file,
-            "        \"{locale_key}\" => Some(r###\"{content}\"###),"
+            "        \"{locale_key}\" => Some(r{delimiter}\"{content}\"{delimiter}),"
         )?;
 
         // Tell Cargo to rerun if this file changes
@@ -298,7 +331,13 @@ fn embed_locale_file(
 }
 
 /// Higher-level helper to embed locale files for a component with a path pattern.
-/// This eliminates the repetitive for_each_locale + embed_locale_file pattern.
+///
+/// This eliminates the repetitive `for_each_locale` + `embed_locale_file` pattern.
+///
+/// # Errors
+///
+/// Returns an error if `for_each_locale` fails, which typically happens if
+/// reading a locale file or writing to the `embedded_file` fails.
 fn embed_component_locales<F>(
     embedded_file: &mut std::fs::File,
     locales: &(String, Option<String>),

src/uucore/src/lib/features/fsext.rs

@@ -201,9 +201,9 @@ fn replace_special_chars(s: &[u8]) -> Vec<u8> {
     // * \011 ASCII horizontal tab with a tab character,
     // * ASCII backslash with an actual backslash character.
     //
-    s.replace(r#"\040"#, " ")
-        .replace(r#"\011"#, "	")
-        .replace(r#"\134"#, r#"\"#)
+    s.replace(r"\040", " ")
+        .replace(r"\011", "	")
+        .replace(r"\134", r"\")
 }
 
 impl MountInfo {
@@ -1171,23 +1171,23 @@ mod tests {
     fn test_mountinfo_dir_special_chars() {
         let info = MountInfo::new(
             LINUX_MOUNTINFO,
-            &br#"317 61 7:0 / /mnt/f\134\040\011oo rw,relatime shared:641 - ext4 /dev/loop0 rw"#
+            &br"317 61 7:0 / /mnt/f\134\040\011oo rw,relatime shared:641 - ext4 /dev/loop0 rw"
                 .split(|c| *c == b' ')
                 .collect::<Vec<_>>(),
         )
         .unwrap();
 
-        assert_eq!(info.mount_dir, r#"/mnt/f\ 	oo"#);
+        assert_eq!(info.mount_dir, r"/mnt/f\ 	oo");
 
         let info = MountInfo::new(
             LINUX_MTAB,
-            &br#"/dev/loop0 /mnt/f\134\040\011oo ext4 rw,relatime 0 0"#
+            &br"/dev/loop0 /mnt/f\134\040\011oo ext4 rw,relatime 0 0"
                 .split(|c| *c == b' ')
                 .collect::<Vec<_>>(),
         )
         .unwrap();
 
-        assert_eq!(info.mount_dir, r#"/mnt/f\ 	oo"#);
+        assert_eq!(info.mount_dir, r"/mnt/f\ 	oo");
     }
 
     #[test]

src/uucore/src/lib/mods/display.rs

@@ -24,7 +24,9 @@
 //! # Ok::<(), std::io::Error>(())
 //! ```
 
+use std::env;
 use std::ffi::OsStr;
+use std::fmt;
 use std::fs::File;
 use std::io::{self, BufWriter, Stdout, StdoutLock, Write as IoWrite};
 
@@ -117,3 +119,18 @@ impl OsWrite for Box<dyn OsWrite> {
         this.write_all_os(buf)
     }
 }
+
+/// Print all environment variables in the format `name=value` with the specified line ending.
+///
+/// This function handles non-UTF-8 environment variable names and values correctly by using
+/// raw bytes on Unix systems.
+pub fn print_all_env_vars<T: fmt::Display>(line_ending: T) -> io::Result<()> {
+    let mut stdout = io::stdout().lock();
+    for (name, value) in env::vars_os() {
+        stdout.write_all_os(&name)?;
+        stdout.write_all(b"=")?;
+        stdout.write_all_os(&value)?;
+        write!(stdout, "{line_ending}")?;
+    }
+    Ok(())
+}

src/uucore/src/lib/mods/locale.rs

@@ -617,35 +617,35 @@ mod tests {
         let temp_dir = TempDir::new().expect("Failed to create temp directory");
 
         // Create en-US.ftl
-        let en_content = r#"
+        let en_content = r"
 greeting = Hello, world!
 welcome = Welcome, { $name }!
 count-items = You have { $count ->
     [one] { $count } item
    *[other] { $count } items
 }
 missing-in-other = This message only exists in English
-"#;
+";
 
         // Create fr-FR.ftl
-        let fr_content = r#"
+        let fr_content = r"
 greeting = Bonjour, le monde!
 welcome = Bienvenue, { $name }!
 count-items = Vous avez { $count ->
     [one] { $count } élément
    *[other] { $count } éléments
 }
-"#;
+";
 
         // Create ja-JP.ftl (Japanese)
-        let ja_content = r#"
+        let ja_content = r"
 greeting = こんにちは、世界！
 welcome = ようこそ、{ $name }さん！
 count-items = { $count }個のアイテムがあります
-"#;
+";
 
         // Create ar-SA.ftl (Arabic - Right-to-Left)
-        let ar_content = r#"
+        let ar_content = r"
 greeting = أهلاً بالعالم！
 welcome = أهلاً وسهلاً، { $name }！
 count-items = لديك { $count ->
@@ -655,13 +655,13 @@ count-items = لديك { $count ->
     [few] { $count } عناصر
    *[other] { $count } عنصر
 }
-"#;
+";
 
         // Create es-ES.ftl with invalid syntax
-        let es_invalid_content = r#"
+        let es_invalid_content = r"
 greeting = Hola, mundo!
 invalid-syntax = This is { $missing
-"#;
+";
 
         fs::write(temp_dir.path().join("en-US.ftl"), en_content)
             .expect("Failed to write en-US.ftl");