Impl getres[ug]id C function.

src/platform/linux/mod.rs

@@ -328,6 +328,37 @@ impl Pal for Sys {
         e_raw(syscall!(GETRLIMIT, resource, rlim)).map(|_| ())
     }
 
+    fn getresgid(
+        rgid: Option<&mut gid_t>,
+        egid: Option<&mut gid_t>,
+        sgid: Option<&mut gid_t>,
+    ) -> Result<()> {
+        unsafe {
+            e_raw(syscall!(
+                GETRESGID,
+                rgid.map_or(0, |r| r as *const _ as usize),
+                egid.map_or(0, |r| r as *const _ as usize),
+                sgid.map_or(0, |r| r as *const _ as usize)
+            ))
+            .map(|_| ())
+        }
+    }
+    fn getresuid(
+        ruid: Option<&mut uid_t>,
+        euid: Option<&mut uid_t>,
+        suid: Option<&mut uid_t>,
+    ) -> Result<()> {
+        unsafe {
+            e_raw(syscall!(
+                GETRESUID,
+                ruid.map_or(0, |r| r as *const _ as usize),
+                euid.map_or(0, |r| r as *const _ as usize),
+                suid.map_or(0, |r| r as *const _ as usize)
+            ))
+            .map(|_| ())
+        }
+    }
+
     unsafe fn setrlimit(resource: c_int, rlimit: *const rlimit) -> Result<()> {
         e_raw(syscall!(SETRLIMIT, resource, rlimit)).map(|_| ())
     }

src/platform/pal/mod.rs

@@ -131,6 +131,18 @@ pub trait Pal {
 
     fn getrandom(buf: &mut [u8], flags: c_uint) -> Result<usize>;
 
+    fn getresgid(
+        rgid: Option<&mut gid_t>,
+        egid: Option<&mut gid_t>,
+        sgid: Option<&mut gid_t>,
+    ) -> Result<()>;
+
+    fn getresuid(
+        ruid: Option<&mut uid_t>,
+        euid: Option<&mut uid_t>,
+        suid: Option<&mut uid_t>,
+    ) -> Result<()>;
+
     unsafe fn getrlimit(resource: c_int, rlim: *mut rlimit) -> Result<()>;
 
     unsafe fn setrlimit(resource: c_int, rlim: *const rlimit) -> Result<()>;

src/platform/redox/mod.rs

@@ -468,6 +468,45 @@ impl Pal for Sys {
         Ok(syscall::read(*fd, buf)?)
     }
 
+    fn getresgid(
+        rgid_out: Option<&mut gid_t>,
+        egid_out: Option<&mut gid_t>,
+        sgid_out: Option<&mut gid_t>,
+    ) -> Result<()> {
+        let Resugid {
+            rgid, egid, sgid, ..
+        } = redox_rt::sys::posix_getresugid();
+        if let Some(rgid_out) = rgid_out {
+            *rgid_out = rgid as _;
+        }
+        if let Some(egid_out) = egid_out {
+            *egid_out = egid as _;
+        }
+        if let Some(sgid_out) = sgid_out {
+            *sgid_out = sgid as _;
+        }
+        Ok(())
+    }
+    fn getresuid(
+        ruid_out: Option<&mut uid_t>,
+        euid_out: Option<&mut uid_t>,
+        suid_out: Option<&mut uid_t>,
+    ) -> Result<()> {
+        let Resugid {
+            ruid, euid, suid, ..
+        } = redox_rt::sys::posix_getresugid();
+        if let Some(ruid_out) = ruid_out {
+            *ruid_out = ruid as _;
+        }
+        if let Some(euid_out) = euid_out {
+            *euid_out = euid as _;
+        }
+        if let Some(suid_out) = suid_out {
+            *suid_out = suid as _;
+        }
+        Ok(())
+    }
+
     unsafe fn getrlimit(resource: c_int, rlim: *mut rlimit) -> Result<()> {
         //TODO
         eprintln!(