use crate::errno::SysResult;
use crate::fd::RawFd;
use crate::raw::{nr, syscall1, syscall2, syscall3, syscall4};
pub const STDIN_FILENO: RawFd = 0;
pub const STDOUT_FILENO: RawFd = 1;
pub const STDERR_FILENO: RawFd = 2;
pub const F_DUPFD: i32 = 0;
pub const F_GETFD: i32 = 1;
pub const F_SETFD: i32 = 2;
pub const F_GETFL: i32 = 3;
pub const F_SETFL: i32 = 4;
pub const F_SETLK: i32 = 6;
pub const F_SETLKW: i32 = 7;
pub const F_DUPFD_CLOEXEC: i32 = 1030;
pub const FD_CLOEXEC: i32 = 1;
pub const F_RDLCK: i16 = 0;
pub const F_WRLCK: i16 = 1;
pub const F_UNLCK: i16 = 2;
pub const TCGETS: u64 = 0x5401;
pub const FIONBIO: u64 = 0x5421;
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct Flock {
pub l_type: i16,
pub l_whence: i16,
pub l_start: i64,
pub l_len: i64,
pub l_pid: i32,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct IoVec {
pub iov_base: *mut u8,
pub iov_len: usize,
}
impl Default for IoVec {
fn default() -> Self {
Self {
iov_base: core::ptr::null_mut(),
iov_len: 0,
}
}
}
pub fn close(fd: RawFd) -> SysResult<()> {
unsafe {
syscall1(nr::CLOSE, fd as usize)?;
}
Ok(())
}
pub unsafe fn read_raw(fd: RawFd, buf: *mut u8, len: usize) -> SysResult<usize> {
unsafe { syscall3(nr::READ, fd as usize, buf as usize, len) }
}
pub fn read(fd: RawFd, buf: &mut [u8]) -> SysResult<usize> {
unsafe { read_raw(fd, buf.as_mut_ptr(), buf.len()) }
}
pub unsafe fn write_raw(fd: RawFd, buf: *const u8, len: usize) -> SysResult<usize> {
unsafe { syscall3(nr::WRITE, fd as usize, buf as usize, len) }
}
pub fn write(fd: RawFd, buf: &[u8]) -> SysResult<usize> {
unsafe { write_raw(fd, buf.as_ptr(), buf.len()) }
}
pub fn pread(fd: RawFd, buf: &mut [u8], offset: i64) -> SysResult<usize> {
unsafe {
syscall4(
nr::PREAD64,
fd as usize,
buf.as_mut_ptr() as usize,
buf.len(),
offset as usize,
)
}
}
pub fn pwrite(fd: RawFd, buf: &[u8], offset: i64) -> SysResult<usize> {
unsafe {
syscall4(
nr::PWRITE64,
fd as usize,
buf.as_ptr() as usize,
buf.len(),
offset as usize,
)
}
}
pub unsafe fn writev(fd: RawFd, iov: &[IoVec]) -> SysResult<usize> {
unsafe { syscall3(nr::WRITEV, fd as usize, iov.as_ptr() as usize, iov.len()) }
}
pub fn pipe2(flags: i32) -> SysResult<[RawFd; 2]> {
let mut fds = [0i32; 2];
unsafe {
syscall2(nr::PIPE2, fds.as_mut_ptr() as usize, flags as u32 as usize)?;
}
Ok(fds)
}
pub fn dup(fd: RawFd) -> SysResult<RawFd> {
let raw = unsafe { syscall1(nr::DUP, fd as usize)? };
Ok(raw as RawFd)
}
pub fn dup2(oldfd: RawFd, newfd: RawFd) -> SysResult<RawFd> {
if oldfd == newfd {
fcntl(oldfd, F_GETFD, 0)?;
Ok(newfd)
} else {
dup3(oldfd, newfd, 0)
}
}
pub fn dup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> SysResult<RawFd> {
let raw = unsafe {
syscall3(
nr::DUP3,
oldfd as usize,
newfd as usize,
flags as u32 as usize,
)?
};
Ok(raw as RawFd)
}
pub fn fcntl(fd: RawFd, cmd: i32, arg: usize) -> SysResult<i32> {
let raw = unsafe { syscall3(nr::FCNTL, fd as usize, cmd as u32 as usize, arg)? };
Ok(raw as i32)
}
pub unsafe fn ioctl(fd: RawFd, request: u64, arg: usize) -> SysResult<i32> {
let raw = unsafe { syscall3(nr::IOCTL, fd as usize, request as usize, arg)? };
Ok(raw as i32)
}
#[must_use]
pub fn isatty(fd: RawFd) -> bool {
let mut termios = [0u8; 64];
unsafe { ioctl(fd, TCGETS, termios.as_mut_ptr() as usize).is_ok() }
}
#[cfg(test)]
mod tests {
use super::*;
use crate::errno::{EBADF, Errno};
use crate::raw::with_mock_syscall;
#[test]
fn dup2_same_fd_validates_with_fcntl_getfd() {
with_mock_syscall(
|nr, args| {
assert_eq!(nr, nr::FCNTL);
assert_eq!(args[0], 5);
assert_eq!(args[1], F_GETFD as usize);
Ok(FD_CLOEXEC as usize)
},
|| {
assert_eq!(dup2(5, 5), Ok(5));
},
);
with_mock_syscall(
|nr, _args| {
assert_eq!(nr, nr::FCNTL);
Err(Errno(EBADF))
},
|| {
assert_eq!(dup2(9, 9), Err(Errno(EBADF)));
},
);
}
#[test]
fn dup2_different_fd_routes_to_dup3() {
with_mock_syscall(
|nr, args| {
assert_eq!(nr, nr::DUP3);
assert_eq!(args[0], 3);
assert_eq!(args[1], 7);
assert_eq!(args[2], 0);
Ok(7)
},
|| {
assert_eq!(dup2(3, 7), Ok(7));
},
);
}
}