Some changes for modern Rust

Author: vrmiguel

src/error.rs

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use std::{any::Any, str::Utf8Error};
 
 #[derive(Debug)]
@@ -14,6 +16,7 @@ pub enum Error {
     Daemonize {
         error: daemonize::Error,
     },
+    #[allow(unused)]
     Unicode {
         error: Utf8Error,
     },
@@ -27,9 +30,6 @@ pub enum Error {
     UnknownMlockall,
     UnknownKill,
     UnknownGetpguid,
-    Thread {
-        error: Box<dyn Any + Send + 'static>,
-    },
 
     #[cfg(feature = "glob-ignore")]
     GlobPattern {
@@ -80,12 +80,6 @@ impl From<std::str::Utf8Error> for Error {
     }
 }
 
-impl From<Box<dyn Any + Send + 'static>> for Error {
-    fn from(error: Box<dyn Any + Send + 'static>) -> Self {
-        Self::Thread { error }
-    }
-}
-
 #[cfg(feature = "glob-ignore")]
 impl From<glob::PatternError> for Error {
     fn from(error: glob::PatternError) -> Self {

src/kill.rs

@@ -1,14 +1,14 @@
 use std::fs;
 use std::time::Duration;
-use std::{ffi::OsStr, time::Instant};
+use std::time::Instant;
 
 use libc::kill;
 use libc::{EINVAL, EPERM, ESRCH, SIGKILL, SIGTERM};
 
 use crate::errno::errno;
 use crate::error::{Error, Result};
 use crate::process::Process;
-use crate::{checked_ffi, cli, utils};
+use crate::{cli, utils};
 
 pub fn choose_victim(
     proc_buf: &mut [u8],
@@ -90,7 +90,7 @@ pub fn choose_victim(
 }
 
 pub fn kill_process(pid: i32, signal: i32) -> Result<()> {
-    let res = checked_ffi! { kill(pid, signal) };
+    let res = unsafe { kill(pid, signal) };
 
     if res == -1 {
         return Err(match errno() {

src/memory/mem_info.rs

@@ -3,7 +3,6 @@ use std::{fmt, mem};
 use libc::sysinfo;
 
 use crate::{
-    checked_ffi,
     error::{Error, Result},
     utils::bytes_to_megabytes,
 };
@@ -24,7 +23,7 @@ fn sys_info() -> Result<sysinfo> {
     let mut sys_info: sysinfo = unsafe { mem::zeroed() };
 
     // Safety: sysinfo() is safe and must not fail when passed a valid reference
-    let ret_val = checked_ffi! { libc::sysinfo(&mut sys_info) };
+    let ret_val = unsafe { libc::sysinfo(&mut sys_info) };
 
     if ret_val != 0 {
         // The only error that sysinfo() can have happens when

src/memory/mem_lock.rs

@@ -2,7 +2,6 @@ use libc::{c_int, mlockall};
 use libc::{EAGAIN, EINVAL, ENOMEM, EPERM};
 use libc::{MCL_CURRENT, MCL_FUTURE};
 
-use crate::checked_ffi;
 use crate::errno::errno;
 use crate::error::{Error, Result};
 
@@ -11,7 +10,7 @@ extern "C" {
 }
 
 pub fn _mlockall_wrapper(flags: c_int) -> Result<()> {
-    let err = checked_ffi! { mlockall(flags) };
+    let err = unsafe { mlockall(flags) };
     if err == 0 {
         return Ok(());
     }
@@ -38,7 +37,7 @@ pub fn lock_memory_pages() -> Result<()> {
     // TODO: check for _MCL_ONFAULT == -1
 
     #[allow(non_snake_case)]
-    let MCL_ONFAULT: c_int = checked_ffi! { _MCL_ONFAULT };
+    let MCL_ONFAULT: c_int = unsafe { _MCL_ONFAULT };
     match _mlockall_wrapper(MCL_CURRENT | MCL_FUTURE | MCL_ONFAULT) {
         Err(err) => {
             eprintln!("First try at mlockall failed: {:?}", err);

src/process.rs

@@ -3,7 +3,6 @@ use std::io::Write;
 
 use libc::getpgid;
 
-use crate::checked_ffi;
 use crate::{
     error::{Error, Result},
     utils::{self, str_from_bytes},
@@ -26,7 +25,7 @@ impl Process {
     /// Returns the current process represented as a Process struct
     /// Unused in the actual code but very often used when debugging
     pub fn this(buf: &mut [u8]) -> Result<Self> {
-        let pid = checked_ffi! { libc::getpid() } as u32;
+        let pid = unsafe { libc::getpid() } as u32;
 
         Self::from_pid(pid, buf)
     }
@@ -36,7 +35,7 @@ impl Process {
     /// TODO: would it be better to check for /proc/<PID>/ in here?
     pub fn is_alive_from_pid(pid: u32) -> bool {
         // Safety: `getpgid` is memory safe
-        let group_id = checked_ffi! { getpgid(pid as i32) };
+        let group_id = unsafe { getpgid(pid as i32) };
 
         group_id > 0
     }

src/uname.rs

@@ -1,7 +1,6 @@
 use std::ffi::CStr;
 use std::mem;
 
-use crate::checked_ffi;
 use crate::error::{Error, Result};
 use crate::linux_version::LinuxVersion;
 use libc::{uname, utsname};
@@ -16,7 +15,7 @@ impl Uname {
         //         can be safely zeroed.
         let mut uts_struct: utsname = unsafe { mem::zeroed() };
 
-        let ret_val = checked_ffi! { uname(&mut uts_struct) };
+        let ret_val = unsafe { uname(&mut uts_struct) };
 
         // uname returns a negative number upon failure
         if ret_val < 0 {

src/utils.rs

@@ -12,26 +12,17 @@ use memchr::memchr;
 use crate::errno::errno;
 use crate::error::{Error, Result};
 
-/// This macro is used whenever we call a C function but
-/// strongly believe that it cannot cause any memory unsafety.
-#[macro_export]
-macro_rules! checked_ffi {
-    ($e: expr) => {
-        unsafe { $e }
-    };
-}
-
 /// Gets the effective user ID of the calling process
 fn effective_user_id() -> u32 {
     // Safety: the POSIX Programmer's Manual states that
     // geteuid will always be successful.
-    checked_ffi! { libc::geteuid() }
+    unsafe { libc::geteuid() }
 }
 
 /// Gets the process group of the process
 /// with the given PID.
 pub fn get_process_group(pid: i32) -> Result<i32> {
-    let pgid = checked_ffi! { getpgid(pid) };
+    let pgid = unsafe { getpgid(pid) };
     if pgid == -1 {
         return Err(match errno() {
             EPERM => Error::NoPermission,
@@ -53,7 +44,7 @@ pub fn running_as_sudo() -> bool {
 pub fn page_size() -> Result<i64> {
     // _SC_PAGESIZE is defined in POSIX.1
     // Safety: no memory unsafety can arise from `sysconf`
-    let page_size = checked_ffi! { sysconf(_SC_PAGESIZE) };
+    let page_size = unsafe { sysconf(_SC_PAGESIZE) };
     if page_size == -1 {
         return Err(Error::SysConfFailed);
     }