pinky: fix panic when outputting to /dev/full (#10562)

- fixes panic by replacing all println with writeln

Author: hideyosh1

src/uu/pinky/src/platform/openbsd.rs

@@ -5,11 +5,12 @@
 // Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
 
 use crate::uu_app;
+use std::io::{Write, stdout};
 use uucore::error::UResult;
 use uucore::translate;
 
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let _matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
-    println!("{}", translate!("pinky-unsupported-openbsd"));
+    writeln!(stdout(), "{}", translate!("pinky-unsupported-openbsd"))?;
     Ok(())
 }

src/uu/pinky/src/platform/unix.rs

@@ -17,6 +17,7 @@ use uucore::utmpx::{self, Utmpx, UtmpxRecord, time};
 
 use std::io::BufReader;
 use std::io::prelude::*;
+use std::io::stdout;
 
 use std::fs::File;
 use std::os::unix::fs::MetadataExt;
@@ -96,9 +97,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     if do_short_format {
-        pk.short_pinky();
+        pk.short_pinky()?;
     } else {
-        pk.long_pinky();
+        pk.long_pinky()?;
     }
     Ok(())
 }
@@ -167,8 +168,9 @@ fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
 }
 
 impl Pinky {
-    fn print_entry(&self, ut: &UtmpxRecord) {
+    fn print_entry(&self, ut: &UtmpxRecord) -> UResult<()> {
         let mut pts_path = PathBuf::from("/dev");
+        let mut stdout = stdout().lock();
         pts_path.push(ut.tty_device().as_str());
 
         let mesg;
@@ -187,7 +189,7 @@ impl Pinky {
             last_change = 0;
         }
 
-        print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
+        write!(stdout, "{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user())?;
 
         if self.include_fullname {
             let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
@@ -196,23 +198,28 @@ impl Pinky {
                 None
             };
             if let Some(fullname) = fullname {
-                print!(" {fullname:<19.19}");
+                write!(stdout, " {fullname:<19.19}")?;
             } else {
-                print!(" {:19}", "        ???");
+                write!(stdout, " {:19}", "        ???")?;
             }
         }
 
-        print!(" {mesg}{:<8.*}", utmpx::UT_LINESIZE, ut.tty_device());
+        write!(
+            stdout,
+            " {mesg}{:<8.*}",
+            utmpx::UT_LINESIZE,
+            ut.tty_device()
+        )?;
 
         if self.include_idle {
             if last_change == 0 {
-                print!(" {:<6}", "?????");
+                write!(stdout, " {:<6}", "?????")?;
             } else {
-                print!(" {:<6}", idle_string(last_change));
+                write!(stdout, " {:<6}", idle_string(last_change))?;
             }
         }
 
-        print!(" {}", time_string(ut));
+        write!(stdout, " {}", time_string(ut))?;
 
         if self.include_where {
             let s: String = if self.do_lookup {
@@ -222,86 +229,100 @@ impl Pinky {
             };
 
             if !s.is_empty() {
-                print!(" {s}");
+                write!(stdout, " {s}")?;
             }
         }
 
-        println!();
+        writeln!(stdout)?;
+        Ok(())
     }
 
-    fn print_heading(&self) {
-        print!("{:<8}", translate!("pinky-column-login"));
+    fn print_heading(&self) -> UResult<()> {
+        let mut stdout = stdout().lock();
+        write!(stdout, "{:<8}", translate!("pinky-column-login"))?;
         if self.include_fullname {
-            print!(" {:<19}", translate!("pinky-column-name"));
+            write!(stdout, " {:<19}", translate!("pinky-column-name"))?;
         }
-        print!(" {:<9}", translate!("pinky-column-tty"));
+        write!(stdout, " {:<9}", translate!("pinky-column-tty"))?;
         if self.include_idle {
-            print!(" {:<6}", translate!("pinky-column-idle"));
+            write!(stdout, " {:<6}", translate!("pinky-column-idle"))?;
         }
-        print!(" {:<16}", translate!("pinky-column-when"));
+        write!(stdout, " {:<16}", translate!("pinky-column-when"))?;
         if self.include_where {
-            print!(" {}", translate!("pinky-column-where"));
+            write!(stdout, " {}", translate!("pinky-column-where"))?;
         }
-        println!();
+        writeln!(stdout)?;
+        Ok(())
     }
 
-    fn short_pinky(&self) {
+    fn short_pinky(&self) -> UResult<()> {
         if self.include_heading {
-            self.print_heading();
+            self.print_heading()?;
         }
         for ut in Utmpx::iter_all_records() {
             if ut.is_user_process()
                 && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
             {
-                self.print_entry(&ut);
+                self.print_entry(&ut)?;
             }
         }
+        Ok(())
     }
 
-    fn long_pinky(&self) {
+    fn long_pinky(&self) -> UResult<()> {
+        let mut stdout = stdout().lock();
         for u in &self.names {
-            print!(
+            write!(
+                stdout,
                 "{} {u:<28}{} ",
                 translate!("pinky-login-name-label"),
                 translate!("pinky-real-life-label")
-            );
+            )?;
             if let Ok(pw) = Passwd::locate(u.as_str()) {
                 let fullname = gecos_to_fullname(&pw).unwrap_or_default();
                 let user_dir = pw.user_dir.unwrap_or_default();
                 let user_shell = pw.user_shell.unwrap_or_default();
-                println!(" {fullname}");
+                writeln!(stdout, " {fullname}")?;
                 if self.include_home_and_shell {
-                    print!("{} {user_dir:<29}", translate!("pinky-directory-label"));
-                    println!("{}  {user_shell}", translate!("pinky-shell-label"));
+                    write!(
+                        stdout,
+                        "{} {user_dir:<29}",
+                        translate!("pinky-directory-label")
+                    )?;
+                    writeln!(stdout, "{}  {user_shell}", translate!("pinky-shell-label"))?;
                 }
                 if self.include_project {
                     let mut p = PathBuf::from(&user_dir);
                     p.push(".project");
                     if let Ok(f) = File::open(p) {
-                        print!("{} ", translate!("pinky-project-label"));
-                        read_to_console(f);
+                        write!(stdout, "{} ", translate!("pinky-project-label"))?;
+                        read_to_console(f)?;
                     }
                 }
                 if self.include_plan {
                     let mut p = PathBuf::from(&user_dir);
                     p.push(".plan");
                     if let Ok(f) = File::open(p) {
-                        println!("{}:", translate!("pinky-plan-label"));
-                        read_to_console(f);
+                        writeln!(stdout, "{}:", translate!("pinky-plan-label"))?;
+                        read_to_console(f)?;
                     }
                 }
-                println!();
+                writeln!(stdout)?;
             } else {
-                println!(" ???");
+                writeln!(stdout, " ???")?;
             }
         }
+        Ok(())
     }
 }
 
-fn read_to_console<F: Read>(f: F) {
+fn read_to_console<F: Read>(f: F) -> UResult<()> {
     let mut reader = BufReader::new(f);
     let mut iobuf = Vec::new();
+    let mut stdout = stdout().lock();
     if reader.read_to_end(&mut iobuf).is_ok() {
-        print!("{}", String::from_utf8_lossy(&iobuf));
+        write!(stdout, "{}", String::from_utf8_lossy(&iobuf))?;
     }
+
+    Ok(())
 }