feat: inspect-platform

Author: kotauskas

Cargo.toml

@@ -22,6 +22,11 @@ exclude = [
     "/Cargo.lock",
 ]
 
+[[bin]]
+name = "inspect-platform"
+path = "inspect-platform/main.rs"
+test = false
+
 [[example]]
 name = "unnamed_pipe_sync"
 path = "examples/unnamed_pipe/sync/main.rs"
@@ -129,9 +134,9 @@ rust_2018_idioms = { level = "deny", priority = -1 }
 dead_code = "allow"
 
 [lints.clippy]
-exit       = "forbid"
 ptr_as_ptr = "forbid"
 
+exit           = "deny"
 get_unwrap     = "deny"
 as_conversions = "deny"
 

inspect-platform/libc_wrappers.rs

@@ -0,0 +1,90 @@
+use {
+    super::*,
+    libc::mode_t,
+    std::{
+        ffi::CStr,
+        io,
+        mem::MaybeUninit,
+        os::unix::{ffi::OsStrExt as _, net::UnixListener, prelude::*},
+        path::Path,
+    },
+};
+
+trait RetExt: Sized {
+    fn is_ok(&self) -> bool;
+    fn val_or_errno<T>(self, f: impl FnOnce(Self) -> T) -> io::Result<T> {
+        if self.is_ok() {
+            Ok(f(self))
+        } else {
+            Err(io::Error::last_os_error())
+        }
+    }
+    fn ok_or_errno(self) -> io::Result<()> { self.val_or_errno(drop) }
+}
+impl RetExt for c_int {
+    fn is_ok(&self) -> bool { *self >= 0 }
+}
+
+pub fn stat(path: &CStr) -> io::Result<libc::stat> {
+    let mut out = MaybeUninit::uninit();
+    unsafe { libc::stat(path.as_ptr(), out.as_mut_ptr()) }
+        .val_or_errno(|_| unsafe { out.assume_init() })
+}
+pub fn fstat(fd: BorrowedFd<'_>) -> io::Result<libc::stat> {
+    let mut out = MaybeUninit::uninit();
+    unsafe { libc::fstat(fd.as_raw_fd(), out.as_mut_ptr()) }
+        .val_or_errno(|_| unsafe { out.assume_init() })
+}
+pub fn fchmod(fd: BorrowedFd<'_>, mode: mode_t) -> io::Result<()> {
+    unsafe { libc::fchmod(fd.as_raw_fd(), mode) }.ok_or_errno()
+}
+
+#[allow(clippy::as_conversions)]
+fn sockaddr_un_init(
+    sau: &mut MaybeUninit<libc::sockaddr_un>,
+    path: &Path,
+) -> io::Result<libc::socklen_t> {
+    const SUN_PATH_LEN: usize = {
+        let sau = unsafe { std::mem::zeroed::<libc::sockaddr_un>() };
+        std::mem::size_of_val(&sau.sun_path)
+    };
+
+    std::os::unix::net::SocketAddr::from_pathname(path)?;
+
+    let sauptr = sau.as_mut_ptr();
+    let path_bytes = path.as_os_str().as_bytes();
+    let pathlen = path_bytes.len();
+    assert!(pathlen <= SUN_PATH_LEN);
+    unsafe {
+        (&raw mut (*sauptr).sun_family).write(libc::AF_UNIX as _);
+        let pathbase = (&raw mut (*sauptr).sun_path).cast::<c_char>();
+        std::ptr::copy_nonoverlapping(path_bytes.as_ptr().cast(), pathbase, path_bytes.len());
+        if path_bytes.len() != SUN_PATH_LEN {
+            pathbase.add(pathlen).write(0);
+        }
+    }
+    let addrlen = std::mem::offset_of!(libc::sockaddr_un, sun_path) + pathlen;
+    Ok(addrlen as _)
+}
+
+pub fn bind_with_hook(
+    path: &Path,
+    f: impl FnOnce(BorrowedFd<'_>) -> io::Result<()>,
+) -> io::Result<UnixListener> {
+    let mut sau = MaybeUninit::<libc::sockaddr_un>::uninit();
+    let addrlen = sockaddr_un_init(&mut sau, path)?;
+
+    let fd = unsafe { libc::socket(libc::AF_UNIX, libc::SOCK_STREAM, 0) }
+        .val_or_errno(|fd| unsafe { OwnedFd::from_raw_fd(fd) })?;
+    f(fd.as_fd())?;
+    unsafe { libc::bind(fd.as_raw_fd(), sau.as_ptr().cast(), addrlen) }.ok_or_errno()?;
+    Ok(fd.into())
+}
+
+pub fn umask(mask: mode_t) -> UmaskGuard { UmaskGuard(unsafe { libc::umask(mask) }) }
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct UmaskGuard(mode_t);
+impl Drop for UmaskGuard {
+    fn drop(&mut self) { std::mem::forget(umask(self.0)) }
+}

inspect-platform/main.rs

@@ -0,0 +1,42 @@
+#![allow(clippy::exit, clippy::incompatible_msrv)]
+use std::ffi::{c_char, c_int, c_long, c_longlong, c_short};
+
+macro_rules! bitwidths {
+    ($($nam:ident),+ $(,)?) => {[$((stringify!($nam), $nam::BITS)),+]};
+}
+#[allow(unused_macros)]
+macro_rules! sizes {
+    ($($nam:ident),+ $(,)?) => {[$((stringify!($nam), ::std::mem::size_of::<$nam>())),+]};
+}
+
+#[cfg(unix)]
+mod libc_wrappers;
+#[cfg(unix)]
+mod unix;
+
+fn maxlen<T>(a: &[(&str, T)]) -> usize { a.iter().map(|&(nm, _)| nm.len()).max().unwrap_or(0) }
+fn print_bitwidths(bw: &[(&str, u32)]) {
+    let width = maxlen(bw);
+    bw.iter().for_each(|&(nm, bw)| println!("{nm:width$} : {bw:>2} bits"));
+}
+#[allow(dead_code)]
+fn print_sizes(sz: &[(&str, usize)]) {
+    let width = maxlen(sz);
+    sz.iter().for_each(|&(nm, sz)| println!("{nm:width$} : {sz:>3} bytes"));
+}
+fn print_signedness(nm: &str, signed: bool) {
+    println!("{nm} is {}signed", if signed { "" } else { "un" })
+}
+
+fn print_common_intro() {
+    print_bitwidths(&bitwidths!(usize, c_char, c_short, c_int, c_long, c_longlong));
+    print_signedness("c_char", c_char::MIN != 0);
+}
+
+fn main() {
+    print_common_intro();
+    #[cfg(unix)]
+    unix::main();
+    #[cfg(not(unix))]
+    println!("Not a Unix system, no further information will be gathered.");
+}