wall: refactor

- put deps in appropariate places
- use `uucore` methods to simplify code and remove a lot of manual
  `unsafe { libc::...

Author: 0jdxt

Cargo.toml

@@ -76,6 +76,7 @@ sysinfo = "0.38"
 tempfile = "3.9.0"
 textwrap = { version = "0.16.0", features = ["terminal_size"] }
 thiserror = "2.0"
+unicode-width = { version = "0.2.2", default-features = false }
 uucore = "0.2.2"
 uuid = { version = "1.16.0", features = ["rng-rand"] }
 uutests = "0.6.0"

src/uu/wall/Cargo.toml

@@ -2,6 +2,7 @@
 name = "uu_wall"
 version = "0.0.1"
 edition = "2021"
+description = "wall ~ Write a mesage to all users."
 
 [lib]
 path = "src/wall.rs"
@@ -11,8 +12,8 @@ name = "wall"
 path = "src/main.rs"
 
 [dependencies]
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["process", "entries"] }
 clap = { workspace = true }
 libc = { workspace = true }
 chrono = { workspace = true }
-unicode-width = "0.2.2"
+unicode-width = { workspace = true }

src/uu/wall/src/wall.rs

@@ -2,27 +2,30 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use uucore::{error::UResult, format_usage, help_about, help_usage};
 
 #[cfg(unix)]
-use uucore::error::USimpleError;
+use uucore::{
+    entries::{Group, Locate},
+    error::USimpleError,
+    process,
+};
 
 const ABOUT: &str = help_about!("wall.md");
 const USAGE: &str = help_usage!("wall.md");
 
 #[cfg(unix)]
 mod unix {
-    use super::{UResult, USimpleError};
+    use super::process;
+
+    use uucore::entries::{uid2usr, Locate, Passwd};
+    use uucore::utmpx::Utmpx;
 
-    use chrono::{DateTime, Local};
-    use libc::{c_char, gid_t};
     use std::{
-        ffi::{CStr, CString},
-        fmt::Write as fw,
+        ffi::CStr,
         fs::OpenOptions,
         io::{BufRead, BufReader, Read, Write},
-        str::FromStr,
         sync::{mpsc, Arc},
-        time::{Duration, SystemTime},
+        time::Duration,
     };
-    use unicode_width::UnicodeWidthChar;
+    use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
 
     const TERM_WIDTH: usize = 79;
     const BLANK: &str = unsafe { str::from_utf8_unchecked(&[b' '; TERM_WIDTH]) };
@@ -35,51 +38,30 @@ mod unix {
     // if group is specified, only print to memebers of the group.
     pub fn wall<R: Read>(
         input: R,
-        group: Option<gid_t>,
+        group: Option<libc::gid_t>,
         timeout: Option<&u64>,
         print_banner: bool,
     ) {
         let msg = makemsg(input, print_banner);
         let mut seen_ttys = Vec::with_capacity(16);
-        loop {
-            // get next user entry and check it is valid
-            let entry = unsafe {
-                let utmpptr = libc::getutxent();
-                if utmpptr.is_null() {
-                    break;
-                }
-                &*utmpptr
-            };
-
-            if entry.ut_user[0] == 0 || entry.ut_type != libc::USER_PROCESS {
+        for record in Utmpx::iter_all_records() {
+            if !record.is_user_process() {
                 continue;
             }
 
             // make sure device is valid
-            let first = entry.ut_line[0].cast_unsigned();
-            if first == 0 || first == b':' {
+            let tty = record.tty_device();
+            if tty.is_empty() || tty.starts_with(':') {
                 continue;
             }
 
             // check group membership
             if let Some(gid) = group {
-                if !is_gr_member(&entry.ut_user, gid) {
+                if !is_gr_member(&record.user(), gid) {
                     continue;
                 }
             }
 
-            // get tty
-            let tty = unsafe {
-                let len = entry
-                    .ut_line
-                    .iter()
-                    .position(|&c| c == 0)
-                    .unwrap_or(entry.ut_line.len());
-
-                let bytes = std::slice::from_raw_parts(entry.ut_line.as_ptr().cast(), len);
-                str::from_utf8_unchecked(bytes).to_owned()
-            };
-
             // output message to device
             if !seen_ttys.contains(&tty) {
                 if let Err(e) = ttymsg(&tty, msg.clone(), timeout) {
@@ -88,7 +70,6 @@ mod unix {
                 seen_ttys.push(tty);
             }
         }
-        unsafe { libc::endutxent() };
     }
 
     // Create the banner and sanitise input
@@ -105,16 +86,7 @@ mod unix {
                 }
             };
 
-            let user = unsafe {
-                let ruid = libc::getuid();
-                let pw = libc::getpwuid(ruid);
-                if !pw.is_null() && !(*pw).pw_name.is_null() {
-                    CStr::from_ptr((*pw).pw_name).to_string_lossy().into_owned()
-                } else {
-                    eprintln!("cannot get passwd uid");
-                    "<someone>".to_string()
-                }
-            };
+            let user = uid2usr(process::getuid()).unwrap_or("<someone>".to_string());
 
             let tty = unsafe {
                 let tty_ptr = libc::ttyname(libc::STDOUT_FILENO);
@@ -126,14 +98,14 @@ mod unix {
                 }
             };
 
-            let date = DateTime::<Local>::from(SystemTime::now()).format("%a %b %e %T %Y");
+            let date = chrono::Local::now().format("%a %b %e %T %Y");
             let banner = format!("Broadcast message from {user}@{hostname} ({tty}) ({date}):");
 
             blank(&mut buf);
             buf += &banner;
             buf.extend(std::iter::repeat_n(
                 ' ',
-                TERM_WIDTH.saturating_sub(banner.len()),
+                TERM_WIDTH.saturating_sub(banner.width()),
             ));
             buf += "\x07\x07\r\n";
         }
@@ -153,6 +125,8 @@ mod unix {
     // - wraps lines by TERM_WIDTH
     // - escapes control characters
     fn sanitise_line(line: &str) -> String {
+        use std::fmt::Write;
+
         let mut buf = String::with_capacity(line.len());
         let mut col = 0;
 
@@ -179,7 +153,7 @@ mod unix {
                 }
                 _ => {
                     buf.push(ch);
-                    col += ch.width_cjk().unwrap_or_default();
+                    col += ch.width().unwrap_or_default();
                 }
             }
 
@@ -196,60 +170,12 @@ mod unix {
     }
 
     // Determine if user is in specified group
-    fn is_gr_member(user: &[c_char], gid: gid_t) -> bool {
-        // make sure user exists in database
-        let pw = unsafe { libc::getpwnam(user.as_ptr()) };
-        if pw.is_null() {
+    fn is_gr_member(user: &str, gid: libc::gid_t) -> bool {
+        let Ok(pw) = Passwd::locate(user) else {
             return false;
-        }
-
-        // if so, check if primary group matches
-        let group = unsafe { (*pw).pw_gid };
-        if gid == group {
-            return true;
-        }
-
-        // on macos, getgrouplist takes c_int as its group argument
-        #[cfg(target_os = "macos")]
-        let group = group.cast_signed();
-
-        // otherwise check gid is in list of supplementary groups user belongs to
-        let mut ngroups = 16;
-        let mut groups = vec![0; ngroups as usize];
-        while unsafe {
-            libc::getgrouplist(user.as_ptr(), group, groups.as_mut_ptr(), &raw mut ngroups)
-        } == -1
-        {
-            // ret -1 means buffer was too small so we resize
-            // according to the returned ngroups value
-            groups.resize(ngroups as usize, 0);
-        }
-
-        #[cfg(target_os = "macos")]
-        let gid = gid.cast_signed();
-        groups.contains(&gid)
-    }
-
-    // Try to get corresponding group gid.
-    pub fn get_group_gid(group: &String) -> UResult<gid_t> {
-        // first we try as a group name
-        let Ok(cname) = CString::from_str(group) else {
-            return Err(USimpleError::new(1, "invalid group argument"));
         };
 
-        let gr = unsafe { libc::getgrnam(cname.as_ptr()) };
-        if !gr.is_null() {
-            return Ok(unsafe { (*gr).gr_gid });
-        }
-
-        // otherwise, try as literal gid
-        let Ok(gid) = group.parse::<gid_t>() else {
-            return Err(USimpleError::new(1, "invalid group argument"));
-        };
-        if unsafe { libc::getgrgid(gid) }.is_null() {
-            return Err(USimpleError::new(1, format!("{group}: unknown gid")));
-        }
-        Ok(gid)
+        gid == pw.gid || pw.belongs_to().contains(&gid)
     }
 
     // Write to the tty device
@@ -337,7 +263,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     // get nobanner flag and check if user is root
     let flag = args.get_flag("nobanner");
-    let print_banner = if flag && unsafe { libc::geteuid() } != 0 {
+    let print_banner = if flag && process::geteuid() != 0 {
         eprintln!("wall: --nobanner is available only for root");
         true
     } else {
@@ -347,7 +273,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // if group exists, map to corresponding gid
     let group = args
         .get_one::<String>("group")
-        .map(unix::get_group_gid)
+        .map(|g| {
+            Group::locate(g.as_str())
+                .map(|g| g.gid)
+                .map_err(|_| USimpleError::new(1, format!("{g}: unknown group")))
+        })
         .transpose()?;
 
     // If we have a single input arg and it exists on disk, treat as a file.
@@ -365,14 +295,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             // When we are not root, but suid or sgid, refuse to read files
             // (e.g. device files) that the user may not have access to.
             // After all, our invoker can easily do "wall < file" instead of "wall file".
-            unsafe {
-                let uid = libc::getuid();
-                if uid > 0 && (uid != libc::geteuid() || libc::getgid() != libc::getegid()) {
-                    return Err(USimpleError::new(
-                        1,
-                        format!("will not read {fname} - use stdin"),
-                    ));
-                }
+            let uid = process::getuid();
+            if uid > 0 && (uid != process::geteuid() || process::getgid() != process::getegid()) {
+                return Err(USimpleError::new(
+                    1,
+                    format!("will not read {fname} - use stdin"),
+                ));
             }
 
             let Ok(f) = File::open(p) else {

tests/by-util/test_wall.rs

@@ -14,7 +14,7 @@ mod tests {
             .arg("fooblywoobly") // assuming this group doesnt exist
             .fails()
             .code_is(1)
-            .stderr_is("wall: invalid group argument\n");
+            .stderr_is("wall: fooblywoobly: unknown group\n");
     }
 
     #[test]
@@ -24,7 +24,7 @@ mod tests {
             .arg("99999") // assuming this group doesnt exist
             .fails()
             .code_is(1)
-            .stderr_is("wall: 99999: unknown gid\n");
+            .stderr_is("wall: 99999: unknown group\n");
     }
 
     #[test]