Fchownat, ptsname and fstatfs (#115)

* add fchownat

* set errno for incorrect einval

* ptsname

* fstatfs and fstatfs64

* set error cval for enotty for invalid fd

* return errno from ptsname_r

Author: KGrewal1

c-scape/src/fs/fchown.rs

@@ -0,0 +1,26 @@
+use crate::convert_res;
+use core::ffi::CStr;
+use libc::{c_char, c_int, c_uint};
+use rustix::fd::BorrowedFd;
+use rustix::fs::AtFlags;
+
+#[no_mangle]
+unsafe extern "C" fn fchownat(
+    dirfd: c_int,
+    pathname: *const c_char,
+    owner: libc::uid_t,
+    group: libc::gid_t,
+    flags: c_int,
+) -> c_int {
+    libc!(libc::fchownat(dirfd, pathname, owner, group, flags));
+
+    let pathname = CStr::from_ptr(pathname);
+    let owner = Some(rustix::process::Uid::from_raw(owner));
+    let group = Some(rustix::process::Gid::from_raw(group));
+    let flags = AtFlags::from_bits_retain(flags as c_uint);
+    let dirfd = BorrowedFd::borrow_raw(dirfd);
+    match convert_res(rustix::fs::chownat(dirfd, pathname, owner, group, flags)) {
+        Some(()) => 0,
+        None => -1,
+    }
+}

c-scape/src/fs/mod.rs

@@ -4,6 +4,7 @@ mod chmod;
 mod dir;
 mod fadvise;
 mod fallocate;
+mod fchown;
 mod fcntl;
 mod flock;
 mod inotify;

c-scape/src/fs/stat.rs

@@ -208,3 +208,60 @@ unsafe extern "C" fn statfs(path: *const c_char, stat_: *mut libc::statfs) -> c_
         None => -1,
     }
 }
+
+#[no_mangle]
+unsafe extern "C" fn fstatfs64(fd: c_int, stat_: *mut libc::statfs64) -> c_int {
+    libc!(libc::fstatfs64(fd, stat_));
+    let stat_: *mut rustix::fs::StatFs = checked_cast!(stat_);
+
+    match convert_res(rustix::fs::fstatfs(BorrowedFd::borrow_raw(fd))) {
+        Some(r) => {
+            *stat_ = r;
+            0
+        }
+        None => -1,
+    }
+}
+
+#[no_mangle]
+unsafe extern "C" fn fstatfs(fd: c_int, stat_: *mut libc::statfs) -> c_int {
+    libc!(libc::fstatfs(fd, stat_));
+
+    match convert_res(rustix::fs::fstatfs(BorrowedFd::borrow_raw(fd))) {
+        Some(r) => {
+            #[cfg(target_os = "linux")]
+            {
+                let mut converted = core::mem::zeroed::<libc::statfs>();
+                converted.f_type = r.f_type.try_into().unwrap();
+                converted.f_bsize = r.f_bsize.try_into().unwrap();
+                converted.f_blocks = r.f_blocks.try_into().unwrap();
+                converted.f_bfree = r.f_bfree.try_into().unwrap();
+                converted.f_bavail = r.f_bavail.try_into().unwrap();
+                converted.f_files = r.f_files.try_into().unwrap();
+                converted.f_ffree = r.f_ffree.try_into().unwrap();
+                converted.f_namelen = r.f_namelen.try_into().unwrap();
+                converted.f_frsize = r.f_frsize.try_into().unwrap();
+
+                // The libc crate declares `f_fsid` with private fields,
+                // perhaps because who even knows what this field means,
+                // but understanding is not required for the job here.
+                assert_eq!(size_of_val(&r.f_fsid), size_of_val(&converted.f_fsid));
+                copy_nonoverlapping(
+                    addr_of!(r.f_fsid).cast::<u8>(),
+                    addr_of_mut!(converted.f_fsid).cast::<u8>(),
+                    size_of_val(&r.f_fsid),
+                );
+
+                *stat_ = converted;
+            }
+
+            #[cfg(not(target_os = "linux"))]
+            {
+                *stat_ = r;
+            }
+
+            0
+        }
+        None => -1,
+    }
+}

c-scape/src/termios_/mod.rs

@@ -3,6 +3,7 @@
 use crate::{convert_res, set_errno, Errno};
 use core::mem::{size_of, transmute, zeroed};
 use core::ops::Index;
+use core::ptr::copy_nonoverlapping;
 use libc::{c_char, c_int, pid_t, termios, winsize};
 use rustix::fd::{BorrowedFd, FromRawFd, IntoRawFd, OwnedFd};
 use rustix::process::Pid;
@@ -545,3 +546,38 @@ unsafe extern "C" fn tcflow(fd: c_int, action: c_int) -> c_int {
         None => -1,
     }
 }
+
+#[no_mangle]
+unsafe extern "C" fn ptsname(fd: c_int) -> *mut c_char {
+    static mut PTS_BUFFER: [c_char; 30] = [0; 30];
+    if ptsname_r(fd, PTS_BUFFER.as_mut_ptr(), PTS_BUFFER.len()) != 0 {
+        core::ptr::null_mut()
+    } else {
+        PTS_BUFFER.as_mut_ptr()
+    }
+}
+
+#[no_mangle]
+unsafe extern "C" fn ptsname_r(fd: c_int, buf: *mut c_char, buflen: libc::size_t) -> c_int {
+    libc!(libc::ptsname_r(fd, buf, buflen));
+    if buf.is_null() {
+        Errno(libc::EINVAL).into()
+    } else {
+        let fd = BorrowedFd::borrow_raw(fd);
+        match rustix::pty::ptsname(fd, []) {
+            Ok(name) => {
+                let len = name.as_bytes().len() + 1; // length inc null terminator
+                if len > buflen {
+                    Errno(libc::ERANGE).into()
+                } else {
+                    // we have checked the string will fit in the buffer
+                    // so can use strcpy safely
+                    let s = name.as_ptr().cast();
+                    copy_nonoverlapping(s, buf, len);
+                    0
+                }
+            }
+            Err(err) => err.raw_os_error(),
+        }
+    }
+}

c-scape/src/todo.rs

@@ -49,18 +49,6 @@ unsafe extern "C" fn eaccess() {
     todo!("eaccess")
 }
 #[no_mangle]
-unsafe extern "C" fn fchownat() {
-    todo!("fchownat")
-}
-#[no_mangle]
-unsafe extern "C" fn fstatfs() {
-    todo!("fstatfs")
-}
-#[no_mangle]
-unsafe extern "C" fn fstatfs64() {
-    todo!("fstatfs64")
-}
-#[no_mangle]
 unsafe extern "C" fn timerfd_gettime() {
     todo!("timerfd_gettime")
 }
@@ -360,14 +348,6 @@ unsafe extern "C" fn ptrace() {
     todo!("ptrace")
 }
 #[no_mangle]
-unsafe extern "C" fn ptsname() {
-    todo!("ptsname")
-}
-#[no_mangle]
-unsafe extern "C" fn ptsname_r() {
-    todo!("ptsname_r")
-}
-#[no_mangle]
 unsafe extern "C" fn forkpty() {
     todo!("forkpty")
 }