Process::environment for macOS (closes #209)

Author: svartalf

heim-process/src/sys/macos/bindings/proc_args.rs

@@ -5,16 +5,20 @@ use std::ptr;
 use heim_common::sys::macos::sysctl;
 use heim_common::{Error, Result};
 
+use crate::Pid;
+
 pub fn args_max() -> Result<libc::c_int> {
     sysctl::sysctl(&mut [libc::CTL_KERN, libc::KERN_ARGMAX])
 }
 
 // TODO: https://chromium.googlesource.com/crashpad/crashpad/+/360e441c53ab4191a6fd2472cc57c3343a2f6944/util/posix/process_util_mac.cc#32
+// TODO: Use `process::ProcessResult`
 #[allow(trivial_casts)]
-pub fn proc_args(pid: libc::pid_t) -> Result<Vec<u8>> {
+pub fn proc_args(pid: Pid) -> Result<Vec<u8>> {
     // Command line for `kernel_task` process can't be fetched
     if pid == 0 {
-        return Ok(Vec::new());
+        // TODO: Return `ProcessError::AccessDenied`
+        return Err(io::Error::from(io::ErrorKind::PermissionDenied).into());
     }
 
     let mut args_max = args_max()? as usize;

heim-process/src/sys/macos/process/command.rs

@@ -1,4 +1,5 @@
 use std::ffi::{OsStr, OsString};
+use std::io;
 use std::os::unix::ffi::OsStrExt;
 
 use crate::sys::macos::{pid_exists, wrappers};
@@ -48,6 +49,9 @@ pub async fn command(pid: Pid) -> ProcessResult<Command> {
                 Err(e.into())
             }
         }
+        Err(e) if e.as_inner().kind() == io::ErrorKind::PermissionDenied => {
+            Err(ProcessError::AccessDenied(pid))
+        }
         Err(e) => Err(e.into()),
     }
 }

heim-process/src/sys/macos/process/env.rs

@@ -0,0 +1,22 @@
+use std::io;
+
+use crate::sys::macos::{pid_exists, wrappers};
+use crate::sys::unix::Environment;
+use crate::{Pid, ProcessError, ProcessResult};
+
+pub async fn environment(pid: Pid) -> ProcessResult<Environment> {
+    match wrappers::ProcArgs::get(pid) {
+        Ok(proc_args) => Ok(proc_args.environment()),
+        Err(e) if e.raw_os_error() == Some(libc::EINVAL) => {
+            if pid_exists(pid).await? {
+                Err(ProcessError::ZombieProcess(pid))
+            } else {
+                Err(e.into())
+            }
+        }
+        Err(e) if e.as_inner().kind() == io::ErrorKind::PermissionDenied => {
+            Err(ProcessError::AccessDenied(pid))
+        }
+        Err(e) => Err(e.into()),
+    }
+}

heim-process/src/sys/macos/process/mod.rs

@@ -20,6 +20,7 @@ use crate::{Pid, ProcessError, ProcessResult, Status};
 
 mod command;
 mod cpu_times;
+mod env;
 mod memory;
 
 pub use self::command::{Command, CommandIter};
@@ -71,6 +72,9 @@ impl Process {
     pub async fn cwd(&self) -> ProcessResult<PathBuf> {
         match darwin_libproc::pid_cwd(self.pid) {
             Ok(path) => Ok(path),
+            Err(e) if e.kind() == io::ErrorKind::PermissionDenied => {
+                Err(ProcessError::AccessDenied(self.pid))
+            }
             Err(e) => Err(catch_zombie(e, self.pid)),
         }
     }
@@ -83,7 +87,7 @@ impl Process {
     }
 
     pub async fn environment(&self) -> ProcessResult<Environment> {
-        unimplemented!()
+        env::environment(self.pid).await
     }
 
     pub async fn create_time(&self) -> ProcessResult<Time> {

heim-process/src/sys/macos/wrappers/proc_args.rs

@@ -3,6 +3,7 @@ use std::ffi::{OsStr, OsString};
 use std::os::unix::ffi::{OsStrExt, OsStringExt};
 
 use crate::sys::macos::bindings;
+use crate::sys::unix::Environment;
 use crate::Pid;
 use heim_common::Result;
 
@@ -29,6 +30,21 @@ impl ProcArgs {
         OsStr::from_bytes(&self.0[start..end])
     }
 
+    pub fn environment(&self) -> Environment {
+        // env vars are starting right after the arguments block
+        // and ends when second `\0` appears.
+        let start = self.arguments_range().1 + 1;
+
+        // This sounds like a dirty hack, but we just pass
+        // all that remaining data into the `Environment`,
+        // which will stop consuming data when it finds that second `\0` byte.
+        //
+        // It looks bad to assume that it will behave correctly,
+        // but doing another one iteration on the bytes in order to find
+        // that trailing null sounds not so great either.
+        Environment::from_bytes(&self.0[start..])
+    }
+
     pub fn arguments(&self) -> ProcArgsArguments<'_> {
         let (start, end) = self.arguments_range();
         ProcArgsArguments {

heim-process/tests/smoke.rs

@@ -55,11 +55,11 @@ async fn smoke_processes() {
         try_method!(process.parent_pid());
         try_method!(process.name());
         try_method!(process.command());
-        #[cfg(not(target_os = "windows"))] // Not implemented yet
         try_method!(process.exe());
+        #[cfg(not(target_os = "windows"))] // Not implemented yet
         try_method!(process.cwd());
         try_method!(process.status());
-        #[cfg(target_os = "linux")] // Not implemented yet for all platforms
+        #[cfg(any(target_os = "linux", target_os = "macos"))] // Not implemented yet for all platforms
         try_method!(process.environment());
         try_method!(process.create_time());
         try_method!(process.cpu_time());