157 lines
4.0 KiB
Rust
157 lines
4.0 KiB
Rust
use crate::{
|
|
c_str::CStr,
|
|
error::{Errno, ResultExt},
|
|
header::{
|
|
fcntl::O_CREAT,
|
|
sys_stat::stat,
|
|
unistd::{SEEK_CUR, SEEK_END, SEEK_SET},
|
|
},
|
|
io,
|
|
out::Out,
|
|
platform::{Pal, Sys, types::*},
|
|
};
|
|
use core::ops::Deref;
|
|
|
|
pub struct File {
|
|
pub fd: c_int,
|
|
/// To avoid self referential FILE struct that needs both a reader and a writer,
|
|
/// make "reference" files that share fd but don't close on drop.
|
|
pub reference: bool,
|
|
}
|
|
|
|
impl File {
|
|
pub fn new(fd: c_int) -> Self {
|
|
Self {
|
|
fd,
|
|
reference: false,
|
|
}
|
|
}
|
|
|
|
pub fn open(path: CStr, oflag: c_int) -> Result<Self, Errno> {
|
|
Sys::open(path, oflag, 0)
|
|
.map(Self::new)
|
|
.map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn openat(dirfd: c_int, path: CStr, oflag: c_int) -> Result<Self, Errno> {
|
|
Sys::openat(dirfd, path, oflag, 0)
|
|
.map(Self::new)
|
|
.map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn create(path: CStr, oflag: c_int, mode: mode_t) -> Result<Self, Errno> {
|
|
Sys::open(path, oflag | O_CREAT, mode)
|
|
.map(Self::new)
|
|
.map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn createat(dirfd: c_int, path: CStr, oflag: c_int, mode: mode_t) -> Result<Self, Errno> {
|
|
Sys::openat(dirfd, path, oflag | O_CREAT, mode)
|
|
.map(Self::new)
|
|
.map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn sync_all(&self) -> Result<(), Errno> {
|
|
Sys::fsync(self.fd).map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn set_len(&self, size: u64) -> Result<(), Errno> {
|
|
Sys::ftruncate(self.fd, size as off_t).map_err(Errno::sync)
|
|
}
|
|
|
|
pub fn fstat(&self) -> Result<stat, Errno> {
|
|
let mut file_st = stat::default();
|
|
Sys::fstat(self.fd, Out::from_mut(&mut file_st)).map_err(Errno::sync)?;
|
|
Ok(file_st)
|
|
}
|
|
|
|
pub fn try_clone(&self) -> io::Result<Self> {
|
|
Ok(Self::new(Sys::dup(self.fd)?))
|
|
}
|
|
|
|
/// Create a new file pointing to the same underlying descriptor. This file
|
|
/// will know it's a "reference" and won't close the fd. It will, however,
|
|
/// not prevent the original file from closing the fd.
|
|
pub unsafe fn get_ref(&self) -> Self {
|
|
Self {
|
|
fd: self.fd,
|
|
reference: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl io::Read for &File {
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
|
match Sys::read(self.fd, buf).map(|read| read as ssize_t).or_minus_one_errno() /* TODO */ {
|
|
-1 => Err(io::last_os_error()),
|
|
ok => Ok(ok as usize),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl io::Write for &File {
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
match Sys::write(self.fd, buf)
|
|
.map(|read| read as ssize_t)
|
|
.or_minus_one_errno()
|
|
{
|
|
-1 => Err(io::last_os_error()),
|
|
ok => Ok(ok as usize),
|
|
}
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl io::Seek for &File {
|
|
fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
|
|
let (offset, whence) = match pos {
|
|
io::SeekFrom::Start(start) => (start as off_t, SEEK_SET),
|
|
io::SeekFrom::Current(current) => (current as off_t, SEEK_CUR),
|
|
io::SeekFrom::End(end) => (end as off_t, SEEK_END),
|
|
};
|
|
|
|
Ok(Sys::lseek(self.fd, offset, whence)? as u64)
|
|
}
|
|
}
|
|
|
|
impl io::Read for File {
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
|
(&mut &*self).read(buf)
|
|
}
|
|
}
|
|
|
|
impl io::Write for File {
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
(&mut &*self).write(buf)
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
(&mut &*self).flush()
|
|
}
|
|
}
|
|
|
|
impl io::Seek for File {
|
|
fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
|
|
(&mut &*self).seek(pos)
|
|
}
|
|
}
|
|
|
|
impl Deref for File {
|
|
type Target = c_int;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.fd
|
|
}
|
|
}
|
|
|
|
impl Drop for File {
|
|
fn drop(&mut self) {
|
|
if !self.reference {
|
|
let _ = Sys::close(self.fd);
|
|
}
|
|
}
|
|
}
|