Print strings directly without UTF-8 sanitization

Author: blyxxyz

src/uu/hashsum/src/hashsum.rs

@@ -25,6 +25,7 @@ use uucore::checksum::detect_algo;
 use uucore::checksum::digest_reader;
 use uucore::checksum::escape_filename;
 use uucore::checksum::perform_checksum_validation;
+use uucore::display::print_verbatim;
 use uucore::error::{UResult, strip_errno};
 use uucore::format_usage;
 use uucore::sum::{Digest, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
@@ -597,7 +598,9 @@ where
             println!("{sum}");
         } else if options.zero {
             // with zero, we don't escape the filename
-            print!("{sum} {binary_marker}{}\0", filename.display());
+            print!("{sum} {binary_marker}");
+            print_verbatim(filename).unwrap();
+            print!("\0");
         } else {
             println!("{prefix}{sum} {binary_marker}{escaped_filename}");
         }

src/uu/head/src/head.rs

@@ -14,7 +14,7 @@ use std::num::TryFromIntError;
 #[cfg(unix)]
 use std::os::fd::{AsRawFd, FromRawFd};
 use thiserror::Error;
-use uucore::display::Quotable;
+use uucore::display::{Quotable, print_verbatim};
 use uucore::error::{FromIo, UError, UResult};
 use uucore::line_ending::LineEnding;
 use uucore::translate;
@@ -522,10 +522,9 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
                 if !first {
                     println!();
                 }
-                match file.to_str() {
-                    Some(name) => println!("==> {name} <=="),
-                    None => println!("==> {} <==", file.to_string_lossy()),
-                }
+                print!("==> ");
+                print_verbatim(file).unwrap();
+                println!(" <==");
             }
             head_file(&mut file_handle, options)?;
             Ok(())

src/uu/sum/src/sum.rs

@@ -10,7 +10,7 @@ use std::ffi::OsString;
 use std::fs::File;
 use std::io::{ErrorKind, Read, Write, stdin, stdout};
 use std::path::Path;
-use uucore::display::Quotable;
+use uucore::display::{OsWrite, Quotable};
 use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::translate;
 
@@ -126,11 +126,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
         let mut stdout = stdout().lock();
         if print_names {
-            writeln!(
-                stdout,
-                "{sum:0width$} {blocks:width$} {}",
-                file.to_string_lossy()
-            )?;
+            write!(stdout, "{sum:0width$} {blocks:width$} ")?;
+            stdout.write_all_os(file)?;
+            stdout.write_all(b"\n")?;
         } else {
             writeln!(stdout, "{sum:0width$} {blocks:width$}")?;
         }

src/uu/tty/src/tty.rs

@@ -7,6 +7,7 @@
 
 use clap::{Arg, ArgAction, Command};
 use std::io::{IsTerminal, Write};
+use uucore::display::OsWrite;
 use uucore::error::{UResult, set_exit_code};
 use uucore::format_usage;
 
@@ -36,7 +37,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let name = nix::unistd::ttyname(std::io::stdin());
 
     let write_result = match name {
-        Ok(name) => writeln!(stdout, "{}", name.display()),
+        Ok(name) => stdout.write_all_os(name.as_os_str()),
         Err(_) => {
             set_exit_code(1);
             writeln!(stdout, "{}", translate!("tty-not-a-tty"))

src/uu/uname/src/uname.rs

@@ -5,8 +5,11 @@
 
 // spell-checker:ignore (API) nodename osname sysname (options) mnrsv mnrsvo
 
+use std::ffi::{OsStr, OsString};
+
 use clap::{Arg, ArgAction, Command};
 use platform_info::*;
+use uucore::display::println_verbatim;
 use uucore::translate;
 use uucore::{
     error::{UResult, USimpleError},
@@ -26,18 +29,18 @@ pub mod options {
 }
 
 pub struct UNameOutput {
-    pub kernel_name: Option<String>,
-    pub nodename: Option<String>,
-    pub kernel_release: Option<String>,
-    pub kernel_version: Option<String>,
-    pub machine: Option<String>,
-    pub os: Option<String>,
-    pub processor: Option<String>,
-    pub hardware_platform: Option<String>,
+    pub kernel_name: Option<OsString>,
+    pub nodename: Option<OsString>,
+    pub kernel_release: Option<OsString>,
+    pub kernel_version: Option<OsString>,
+    pub machine: Option<OsString>,
+    pub os: Option<OsString>,
+    pub processor: Option<OsString>,
+    pub hardware_platform: Option<OsString>,
 }
 
 impl UNameOutput {
-    fn display(&self) -> String {
+    fn display(&self) -> OsString {
         [
             self.kernel_name.as_ref(),
             self.nodename.as_ref(),
@@ -50,9 +53,9 @@ impl UNameOutput {
         ]
         .into_iter()
         .flatten()
-        .map(|name| name.as_str())
+        .map(|name| name.as_os_str())
         .collect::<Vec<_>>()
-        .join(" ")
+        .join(OsStr::new(" "))
     }
 
     pub fn new(opts: &Options) -> UResult<Self> {
@@ -68,30 +71,28 @@ impl UNameOutput {
             || opts.processor
             || opts.hardware_platform);
 
-        let kernel_name = (opts.kernel_name || opts.all || none)
-            .then(|| uname.sysname().to_string_lossy().to_string());
+        let kernel_name =
+            (opts.kernel_name || opts.all || none).then(|| uname.sysname().to_owned());
 
-        let nodename =
-            (opts.nodename || opts.all).then(|| uname.nodename().to_string_lossy().to_string());
+        let nodename = (opts.nodename || opts.all).then(|| uname.nodename().to_owned());
 
-        let kernel_release = (opts.kernel_release || opts.all)
-            .then(|| uname.release().to_string_lossy().to_string());
+        let kernel_release = (opts.kernel_release || opts.all).then(|| uname.release().to_owned());
 
-        let kernel_version = (opts.kernel_version || opts.all)
-            .then(|| uname.version().to_string_lossy().to_string());
+        let kernel_version = (opts.kernel_version || opts.all).then(|| uname.version().to_owned());
 
-        let machine =
-            (opts.machine || opts.all).then(|| uname.machine().to_string_lossy().to_string());
+        let machine = (opts.machine || opts.all).then(|| uname.machine().to_owned());
 
-        let os = (opts.os || opts.all).then(|| uname.osname().to_string_lossy().to_string());
+        let os = (opts.os || opts.all).then(|| uname.osname().to_owned());
 
         // This option is unsupported on modern Linux systems
         // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-        let processor = opts.processor.then(|| translate!("uname-unknown"));
+        let processor = opts.processor.then(|| translate!("uname-unknown").into());
 
         // This option is unsupported on modern Linux systems
         // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-        let hardware_platform = opts.hardware_platform.then(|| translate!("uname-unknown"));
+        let hardware_platform = opts
+            .hardware_platform
+            .then(|| translate!("uname-unknown").into());
 
         Ok(Self {
             kernel_name,
@@ -134,7 +135,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         os: matches.get_flag(options::OS),
     };
     let output = UNameOutput::new(&options)?;
-    println!("{}", output.display());
+    println_verbatim(output.display().as_os_str()).unwrap();
     Ok(())
 }