From f955b6f455210740ceb9714ab222cfb0bd310261 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 20 Mar 2024 21:23:01 -0700 Subject: [PATCH 1/2] Show mode_t as octal in std::fs Debug impls --- library/std/src/sys/pal/unix/fs.rs | 108 +++++++++++++++++++++-- library/std/src/sys/pal/unix/fs/tests.rs | 59 +++++++++++++ 2 files changed, 162 insertions(+), 5 deletions(-) create mode 100644 library/std/src/sys/pal/unix/fs/tests.rs diff --git a/library/std/src/sys/pal/unix/fs.rs b/library/std/src/sys/pal/unix/fs.rs index b968f8df34c23..5a61fb4ac2036 100644 --- a/library/std/src/sys/pal/unix/fs.rs +++ b/library/std/src/sys/pal/unix/fs.rs @@ -1,10 +1,13 @@ // miri has some special hacks here that make things unused. #![cfg_attr(miri, allow(unused))] +#[cfg(test)] +mod tests; + use crate::os::unix::prelude::*; use crate::ffi::{CStr, OsStr, OsString}; -use crate::fmt; +use crate::fmt::{self, Write as _}; use crate::io::{self, BorrowedCursor, Error, IoSlice, IoSliceMut, SeekFrom}; use crate::mem; use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd}; @@ -354,7 +357,7 @@ pub struct DirEntry { entry: dirent64, } -#[derive(Clone, Debug)] +#[derive(Clone)] pub struct OpenOptions { // generic read: bool, @@ -368,7 +371,7 @@ pub struct OpenOptions { mode: mode_t, } -#[derive(Clone, PartialEq, Eq, Debug)] +#[derive(Clone, PartialEq, Eq)] pub struct FilePermissions { mode: mode_t, } @@ -381,7 +384,7 @@ pub struct FileTimes { created: Option, } -#[derive(Copy, Clone, Eq, Debug)] +#[derive(Copy, Clone, Eq)] pub struct FileType { mode: mode_t, } @@ -398,11 +401,12 @@ impl core::hash::Hash for FileType { } } -#[derive(Debug)] pub struct DirBuilder { mode: mode_t, } +struct Mode(mode_t); + cfg_has_statx! {{ impl FileAttr { fn from_stat64(stat: stat64) -> Self { @@ -673,12 +677,26 @@ impl FileType { } } +impl fmt::Debug for FileType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let FileType { mode } = self; + f.debug_struct("FileType").field("mode", &Mode(*mode)).finish() + } +} + impl FromInner for FilePermissions { fn from_inner(mode: u32) -> FilePermissions { FilePermissions { mode: mode as mode_t } } } +impl fmt::Debug for FilePermissions { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let FilePermissions { mode } = self; + f.debug_struct("FilePermissions").field("mode", &Mode(*mode)).finish() + } +} + impl fmt::Debug for ReadDir { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // This will only be called from std::fs::ReadDir, which will add a "ReadDir()" frame. @@ -1116,6 +1134,23 @@ impl OpenOptions { } } +impl fmt::Debug for OpenOptions { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let OpenOptions { read, write, append, truncate, create, create_new, custom_flags, mode } = + self; + f.debug_struct("OpenOptions") + .field("read", read) + .field("write", write) + .field("append", append) + .field("truncate", truncate) + .field("create", create) + .field("create_new", create_new) + .field("custom_flags", custom_flags) + .field("mode", &Mode(*mode)) + .finish() + } +} + impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result { run_path_with_cstr(path, &|path| File::open_c(path, opts)) @@ -1402,6 +1437,13 @@ impl DirBuilder { } } +impl fmt::Debug for DirBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let DirBuilder { mode } = self; + f.debug_struct("DirBuilder").field("mode", &Mode(*mode)).finish() + } +} + impl AsInner for File { #[inline] fn as_inner(&self) -> &FileDesc { @@ -1574,6 +1616,62 @@ impl fmt::Debug for File { } } +// Format in octal, followed by the mode format used in `ls -l`. +// +// References: +// https://pubs.opengroup.org/onlinepubs/009696899/utilities/ls.html +// https://www.gnu.org/software/libc/manual/html_node/Testing-File-Type.html +// https://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html +// +// Example: +// 0o100664 (-rw-rw-r--) +impl fmt::Debug for Mode { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self(mode) = self; + write!(f, "0o{mode:06o}")?; + + let entry_type = match mode & libc::S_IFMT { + libc::S_IFDIR => 'd', + libc::S_IFBLK => 'b', + libc::S_IFCHR => 'c', + libc::S_IFLNK => 'l', + libc::S_IFIFO => 'p', + libc::S_IFREG => '-', + _ => return Ok(()), + }; + + f.write_str(" (")?; + f.write_char(entry_type)?; + + // Owner permissions + f.write_char(if mode & libc::S_IRUSR != 0 { 'r' } else { '-' })?; + f.write_char(if mode & libc::S_IWUSR != 0 { 'w' } else { '-' })?; + f.write_char(match (mode & libc::S_IXUSR != 0, mode & libc::S_ISUID != 0) { + (true, true) => 's', // executable and setuid + (false, true) => 'S', // setuid + (true, false) => 'x', // executable + (false, false) => '-', + })?; + + // Group permissions + f.write_char(if mode & libc::S_IRGRP != 0 { 'r' } else { '-' })?; + f.write_char(if mode & libc::S_IWGRP != 0 { 'w' } else { '-' })?; + f.write_char(match (mode & libc::S_IXGRP != 0, mode & libc::S_ISGID != 0) { + (true, true) => 's', // executable and setgid + (false, true) => 'S', // setgid + (true, false) => 'x', // executable + (false, false) => '-', + })?; + + // Other permissions + f.write_char(if mode & libc::S_IROTH != 0 { 'r' } else { '-' })?; + f.write_char(if mode & libc::S_IWOTH != 0 { 'w' } else { '-' })?; + f.write_char(if mode & libc::S_IXOTH != 0 { 'x' } else { '-' })?; + + f.write_char(')') + } +} + pub fn readdir(path: &Path) -> io::Result { let ptr = run_path_with_cstr(path, &|p| unsafe { Ok(libc::opendir(p.as_ptr())) })?; if ptr.is_null() { diff --git a/library/std/src/sys/pal/unix/fs/tests.rs b/library/std/src/sys/pal/unix/fs/tests.rs new file mode 100644 index 0000000000000..9e64f9fe3d701 --- /dev/null +++ b/library/std/src/sys/pal/unix/fs/tests.rs @@ -0,0 +1,59 @@ +use crate::sys::pal::unix::fs::FilePermissions; +use crate::sys_common::FromInner; + +#[test] +fn test_debug_permissions() { + for (expected, mode) in [ + // typical directory + ("FilePermissions { mode: 0o040775 (drwxrwxr-x) }", 0o04_0775), + // typical text file + ("FilePermissions { mode: 0o100664 (-rw-rw-r--) }", 0o10_0664), + // setuid executable (/usr/bin/doas) + ("FilePermissions { mode: 0o104755 (-rwsr-xr-x) }", 0o10_4755), + // char device (/dev/zero) + ("FilePermissions { mode: 0o020666 (crw-rw-rw-) }", 0o02_0666), + // block device (/dev/vda) + ("FilePermissions { mode: 0o060660 (brw-rw----) }", 0o06_0660), + // symbolic link + ("FilePermissions { mode: 0o120777 (lrwxrwxrwx) }", 0o12_0777), + // fifo + ("FilePermissions { mode: 0o010664 (prw-rw-r--) }", 0o01_0664), + // none + ("FilePermissions { mode: 0o100000 (----------) }", 0o10_0000), + // unrecognized + ("FilePermissions { mode: 0o000001 }", 1), + ] { + assert_eq!(format!("{:?}", FilePermissions::from_inner(mode)), expected); + } + + for (expected, mode) in [ + // owner readable + ("FilePermissions { mode: 0o100400 (-r--------) }", libc::S_IRUSR), + // owner writable + ("FilePermissions { mode: 0o100200 (--w-------) }", libc::S_IWUSR), + // owner executable + ("FilePermissions { mode: 0o100100 (---x------) }", libc::S_IXUSR), + // setuid + ("FilePermissions { mode: 0o104000 (---S------) }", libc::S_ISUID), + // owner executable and setuid + ("FilePermissions { mode: 0o104100 (---s------) }", libc::S_IXUSR | libc::S_ISUID), + // group readable + ("FilePermissions { mode: 0o100040 (----r-----) }", libc::S_IRGRP), + // group writable + ("FilePermissions { mode: 0o100020 (-----w----) }", libc::S_IWGRP), + // group executable + ("FilePermissions { mode: 0o100010 (------x---) }", libc::S_IXGRP), + // setgid + ("FilePermissions { mode: 0o102000 (------S---) }", libc::S_ISGID), + // group executable and setgid + ("FilePermissions { mode: 0o102010 (------s---) }", libc::S_IXGRP | libc::S_ISGID), + // other readable + ("FilePermissions { mode: 0o100004 (-------r--) }", libc::S_IROTH), + // other writeable + ("FilePermissions { mode: 0o100002 (--------w-) }", libc::S_IWOTH), + // other executable + ("FilePermissions { mode: 0o100001 (---------x) }", libc::S_IXOTH), + ] { + assert_eq!(format!("{:?}", FilePermissions::from_inner(libc::S_IFREG | mode)), expected); + } +} From 18f7272514cdb87b3359dddd6a152d080bb74d89 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 27 Mar 2024 01:18:29 -0700 Subject: [PATCH 2/2] Use Mode instead of mode_t in fields --- library/std/src/sys/pal/unix/fs.rs | 122 ++++++++++++++--------------- 1 file changed, 57 insertions(+), 65 deletions(-) diff --git a/library/std/src/sys/pal/unix/fs.rs b/library/std/src/sys/pal/unix/fs.rs index 5a61fb4ac2036..024e36848dd72 100644 --- a/library/std/src/sys/pal/unix/fs.rs +++ b/library/std/src/sys/pal/unix/fs.rs @@ -10,6 +10,7 @@ use crate::ffi::{CStr, OsStr, OsString}; use crate::fmt::{self, Write as _}; use crate::io::{self, BorrowedCursor, Error, IoSlice, IoSliceMut, SeekFrom}; use crate::mem; +use crate::ops::{BitAnd, BitAndAssign, BitOrAssign}; use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd}; use crate::path::{Path, PathBuf}; use crate::ptr; @@ -357,7 +358,7 @@ pub struct DirEntry { entry: dirent64, } -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct OpenOptions { // generic read: bool, @@ -368,12 +369,12 @@ pub struct OpenOptions { create_new: bool, // system-specific custom_flags: i32, - mode: mode_t, + mode: Mode, } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Debug)] pub struct FilePermissions { - mode: mode_t, + mode: Mode, } #[derive(Copy, Clone, Debug, Default)] @@ -384,9 +385,9 @@ pub struct FileTimes { created: Option, } -#[derive(Copy, Clone, Eq)] +#[derive(Copy, Clone, Eq, Debug)] pub struct FileType { - mode: mode_t, + mode: Mode, } impl PartialEq for FileType { @@ -401,10 +402,12 @@ impl core::hash::Hash for FileType { } } +#[derive(Debug)] pub struct DirBuilder { - mode: mode_t, + mode: Mode, } +#[derive(Copy, Clone, PartialEq, Eq)] struct Mode(mode_t); cfg_has_statx! {{ @@ -456,11 +459,11 @@ impl FileAttr { self.stat.st_size as u64 } pub fn perm(&self) -> FilePermissions { - FilePermissions { mode: (self.stat.st_mode as mode_t) } + FilePermissions { mode: Mode(self.stat.st_mode as mode_t) } } pub fn file_type(&self) -> FileType { - FileType { mode: self.stat.st_mode as mode_t } + FileType { mode: Mode(self.stat.st_mode as mode_t) } } } @@ -638,7 +641,7 @@ impl FilePermissions { } } pub fn mode(&self) -> u32 { - self.mode as u32 + self.mode.0 as u32 } } @@ -673,27 +676,13 @@ impl FileType { } fn masked(&self) -> mode_t { - self.mode & libc::S_IFMT - } -} - -impl fmt::Debug for FileType { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let FileType { mode } = self; - f.debug_struct("FileType").field("mode", &Mode(*mode)).finish() + self.mode.0 & libc::S_IFMT } } impl FromInner for FilePermissions { fn from_inner(mode: u32) -> FilePermissions { - FilePermissions { mode: mode as mode_t } - } -} - -impl fmt::Debug for FilePermissions { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let FilePermissions { mode } = self; - f.debug_struct("FilePermissions").field("mode", &Mode(*mode)).finish() + FilePermissions { mode: Mode(mode as mode_t) } } } @@ -940,13 +929,13 @@ impl DirEntry { )))] pub fn file_type(&self) -> io::Result { match self.entry.d_type { - libc::DT_CHR => Ok(FileType { mode: libc::S_IFCHR }), - libc::DT_FIFO => Ok(FileType { mode: libc::S_IFIFO }), - libc::DT_LNK => Ok(FileType { mode: libc::S_IFLNK }), - libc::DT_REG => Ok(FileType { mode: libc::S_IFREG }), - libc::DT_SOCK => Ok(FileType { mode: libc::S_IFSOCK }), - libc::DT_DIR => Ok(FileType { mode: libc::S_IFDIR }), - libc::DT_BLK => Ok(FileType { mode: libc::S_IFBLK }), + libc::DT_CHR => Ok(FileType { mode: Mode(libc::S_IFCHR) }), + libc::DT_FIFO => Ok(FileType { mode: Mode(libc::S_IFIFO) }), + libc::DT_LNK => Ok(FileType { mode: Mode(libc::S_IFLNK) }), + libc::DT_REG => Ok(FileType { mode: Mode(libc::S_IFREG) }), + libc::DT_SOCK => Ok(FileType { mode: Mode(libc::S_IFSOCK) }), + libc::DT_DIR => Ok(FileType { mode: Mode(libc::S_IFDIR) }), + libc::DT_BLK => Ok(FileType { mode: Mode(libc::S_IFBLK) }), _ => self.metadata().map(|m| m.file_type()), } } @@ -1068,7 +1057,7 @@ impl OpenOptions { create_new: false, // system-specific custom_flags: 0, - mode: 0o666, + mode: Mode(0o666), } } @@ -1095,7 +1084,7 @@ impl OpenOptions { self.custom_flags = flags; } pub fn mode(&mut self, mode: u32) { - self.mode = mode as mode_t; + self.mode.0 = mode as mode_t; } fn get_access_mode(&self) -> io::Result { @@ -1134,23 +1123,6 @@ impl OpenOptions { } } -impl fmt::Debug for OpenOptions { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let OpenOptions { read, write, append, truncate, create, create_new, custom_flags, mode } = - self; - f.debug_struct("OpenOptions") - .field("read", read) - .field("write", write) - .field("append", append) - .field("truncate", truncate) - .field("create", create) - .field("create_new", create_new) - .field("custom_flags", custom_flags) - .field("mode", &Mode(*mode)) - .finish() - } -} - impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result { run_path_with_cstr(path, &|path| File::open_c(path, opts)) @@ -1165,7 +1137,7 @@ impl File { // some platforms (like macOS, where `open64` is actually `open`), `mode_t` is `u16`. // However, since this is a variadic function, C integer promotion rules mean that on // the ABI level, this still gets passed as `c_int` (aka `u32` on Unix platforms). - let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode as c_int) })?; + let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode.0 as c_int) })?; Ok(File(unsafe { FileDesc::from_raw_fd(fd) })) } @@ -1329,7 +1301,7 @@ impl File { } pub fn set_permissions(&self, perm: FilePermissions) -> io::Result<()> { - cvt_r(|| unsafe { libc::fchmod(self.as_raw_fd(), perm.mode) })?; + cvt_r(|| unsafe { libc::fchmod(self.as_raw_fd(), perm.mode.0) })?; Ok(()) } @@ -1425,22 +1397,15 @@ impl File { impl DirBuilder { pub fn new() -> DirBuilder { - DirBuilder { mode: 0o777 } + DirBuilder { mode: Mode(0o777) } } pub fn mkdir(&self, p: &Path) -> io::Result<()> { - run_path_with_cstr(p, &|p| cvt(unsafe { libc::mkdir(p.as_ptr(), self.mode) }).map(|_| ())) + run_path_with_cstr(p, &|p| cvt(unsafe { libc::mkdir(p.as_ptr(), self.mode.0) }).map(|_| ())) } pub fn set_mode(&mut self, mode: u32) { - self.mode = mode as mode_t; - } -} - -impl fmt::Debug for DirBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let DirBuilder { mode } = self; - f.debug_struct("DirBuilder").field("mode", &Mode(*mode)).finish() + self.mode.0 = mode as mode_t; } } @@ -1672,6 +1637,31 @@ impl fmt::Debug for Mode { } } +impl BitAnd for Mode { + type Output = Mode; + fn bitand(self, rhs: mode_t) -> Self::Output { + Mode(self.0 & rhs) + } +} + +impl BitAndAssign for Mode { + fn bitand_assign(&mut self, rhs: mode_t) { + self.0 &= rhs; + } +} + +impl BitOrAssign for Mode { + fn bitor_assign(&mut self, rhs: mode_t) { + self.0 |= rhs; + } +} + +impl PartialEq for Mode { + fn eq(&self, rhs: &mode_t) -> bool { + self.0 == *rhs + } +} + pub fn readdir(path: &Path) -> io::Result { let ptr = run_path_with_cstr(path, &|p| unsafe { Ok(libc::opendir(p.as_ptr())) })?; if ptr.is_null() { @@ -1696,7 +1686,9 @@ pub fn rename(old: &Path, new: &Path) -> io::Result<()> { } pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { - run_path_with_cstr(p, &|p| cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) }).map(|_| ())) + run_path_with_cstr(p, &|p| { + cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode.0) }).map(|_| ()) + }) } pub fn rmdir(p: &Path) -> io::Result<()> {