std/sys/fs/unix/

dir.rs

use libc::{c_int, mkdirat, renameat, unlinkat};

cfg_select! {
    not(any(
        all(target_os = "linux", not(target_env = "musl")),
        target_os = "l4re",
        target_os = "hurd",
    )) => {
        use libc::{fstatat as fstatat64, openat as openat64};
    }
    _ => {
        use libc::{fstatat64, openat64};
    }
}

use super::{open64, stat64};
use crate::ffi::CStr;
use crate::os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd};
#[cfg(target_family = "unix")]
use crate::os::unix::io::{AsRawFd, FromRawFd};
#[cfg(target_os = "wasi")]
use crate::os::wasi::io::{AsRawFd, FromRawFd};
use crate::path::Path;
use crate::sys::fd::FileDesc;
use crate::sys::fs::OpenOptions;
use crate::sys::fs::unix::{File, FileAttr, debug_path_fd};
use crate::sys::helpers::run_path_with_cstr;
use crate::sys::{AsInner, FromInner, IntoInner, cvt, cvt_r};
use crate::{fmt, fs, io, mem};

const TRAVERSE_DIRECTORY: i32 =
    cfg_select! {
        any(target_os = "freebsd", target_os = "aix") => libc::O_EXEC,
        any(target_os = "linux", target_os = "android", target_os = "l4re") => libc::O_PATH,
        target_os = "illumos" => libc::O_SEARCH,
        _ => libc::O_RDONLY,
    };

pub struct Dir(pub(super) OwnedFd);

impl Dir {
    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<Self> {
        run_path_with_cstr(path, &|path| Self::open_with_c(path, opts))
    }

    pub fn open_for_traversal(path: &Path) -> io::Result<Self> {
        run_path_with_cstr(path, &|path| Self::open_traversal_c(path))
    }

    pub fn duplicate(&self) -> io::Result<Self> {
        Ok(Self(self.0.try_clone()?))
    }

    pub fn open_file(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
        run_path_with_cstr(path.as_ref(), &|path| self.open_file_c(path, opts, 0))
            .map(FileDesc::from_inner)
            .map(File)
    }

    pub fn self_metadata(&self) -> io::Result<FileAttr> {
        // Reuse the implementation for files, which should work for all FDs.
        let fd = self.0.as_raw_fd();
        let f = core::mem::ManuallyDrop::new(File(
            // SAFETY: we borrowed `self` so the FD will not be closed while this function runs.
            unsafe { FileDesc::from_raw_fd(fd) },
        ));
        f.file_attr()
    }

    pub fn remove_file(&self, path: &Path) -> io::Result<()> {
        run_path_with_cstr(path, &|path| self.remove_c(path, /* remove_dir */ false))
    }

    pub fn rename(&self, from: &Path, to_dir: &Self, to: &Path) -> io::Result<()> {
        run_path_with_cstr(from, &|from| {
            run_path_with_cstr(to, &|to| self.rename_c(from, to_dir, to))
        })
    }

    pub fn open_dir(&self, path: &Path, opts: &OpenOptions) -> io::Result<Self> {
        run_path_with_cstr(path, &|path| self.open_file_c(path, opts, libc::O_DIRECTORY)).map(Self)
    }

    pub fn create_dir(&self, path: &Path) -> io::Result<()> {
        run_path_with_cstr(path.as_ref(), &|path| self.create_dir_c(path))
    }

    pub fn remove_dir(&self, path: &Path) -> io::Result<()> {
        run_path_with_cstr(path, &|path| self.remove_c(path, /* remove_dir */ true))
    }

    pub fn metadata(&self, path: &Path) -> io::Result<FileAttr> {
        run_path_with_cstr(path, &|path| {
            self.metadata_c(path, /* symlink_nofollow */ false)
        })
    }

    pub fn symlink_metadata(&self, path: &Path) -> io::Result<FileAttr> {
        run_path_with_cstr(path, &|path| self.metadata_c(path, /* symlink_nofollow */ true))
    }

    fn open_with_c(path: &CStr, opts: &OpenOptions) -> io::Result<Self> {
        let flags = libc::O_CLOEXEC
            | libc::O_DIRECTORY
            | opts.get_access_mode()?
            | opts.get_creation_mode()?
            | (opts.custom_flags as c_int & !libc::O_ACCMODE);
        let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode as c_int) })?;
        Ok(Self(unsafe { OwnedFd::from_raw_fd(fd) }))
    }

    fn open_traversal_c(path: &CStr) -> io::Result<Self> {
        let flags = libc::O_CLOEXEC | libc::O_DIRECTORY | TRAVERSE_DIRECTORY;
        let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, 0) })?;
        Ok(Self(unsafe { OwnedFd::from_raw_fd(fd) }))
    }

    fn open_file_c(
        &self,
        path: &CStr,
        opts: &OpenOptions,
        extra_flags: c_int,
    ) -> io::Result<OwnedFd> {
        let flags = libc::O_CLOEXEC
            | opts.get_access_mode()?
            | opts.get_creation_mode()?
            | (opts.custom_flags as c_int & !libc::O_ACCMODE)
            | extra_flags;
        let fd = cvt_r(|| unsafe {
            openat64(self.0.as_raw_fd(), path.as_ptr(), flags, opts.mode as c_int)
        })?;
        Ok(unsafe { OwnedFd::from_raw_fd(fd) })
    }

    fn remove_c(&self, path: &CStr, remove_dir: bool) -> io::Result<()> {
        cvt(unsafe {
            unlinkat(
                self.0.as_raw_fd(),
                path.as_ptr(),
                if remove_dir { libc::AT_REMOVEDIR } else { 0 },
            )
        })
        .map(|_| ())
    }

    fn rename_c(&self, from: &CStr, to_dir: &Self, to: &CStr) -> io::Result<()> {
        cvt(unsafe {
            renameat(self.0.as_raw_fd(), from.as_ptr(), to_dir.0.as_raw_fd(), to.as_ptr())
        })
        .map(|_| ())
    }

    fn create_dir_c(&self, path: &CStr) -> io::Result<()> {
        cvt(unsafe { mkdirat(self.0.as_raw_fd(), path.as_ptr(), 0o777) }).map(|_| ())
    }

    pub(super) fn metadata_c(&self, path: &CStr, symlink_nofollow: bool) -> io::Result<FileAttr> {
        let fd = self.0.as_raw_fd();
        let flag = if symlink_nofollow { libc::AT_SYMLINK_NOFOLLOW } else { 0 };

        cfg_has_statx! {
            if let Some(ret) = unsafe { super::try_statx(
                fd,
                path.as_ptr(),
                flag | libc::AT_STATX_SYNC_AS_STAT,
                libc::STATX_BASIC_STATS | libc::STATX_BTIME,
            ) } {
                return ret;
            }
        }

        let mut stat: stat64 = unsafe { mem::zeroed() };
        cvt(unsafe { fstatat64(fd, path.as_ptr(), &mut stat, flag) })?;
        Ok(FileAttr::from_stat64(stat))
    }
}

impl fmt::Debug for Dir {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let fd = self.0.as_raw_fd();
        let mut b = debug_path_fd(fd, f, "Dir");
        b.finish()
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl AsRawFd for fs::Dir {
    fn as_raw_fd(&self) -> RawFd {
        self.as_inner().0.as_raw_fd()
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl IntoRawFd for fs::Dir {
    fn into_raw_fd(self) -> RawFd {
        self.into_inner().0.into_raw_fd()
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl FromRawFd for fs::Dir {
    unsafe fn from_raw_fd(fd: RawFd) -> Self {
        Self::from_inner(Dir(unsafe { FromRawFd::from_raw_fd(fd) }))
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl AsFd for fs::Dir {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.as_inner().0.as_fd()
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl From<fs::Dir> for OwnedFd {
    fn from(value: fs::Dir) -> Self {
        value.into_inner().0
    }
}

#[unstable(feature = "dirfd", issue = "120426")]
impl From<OwnedFd> for fs::Dir {
    fn from(value: OwnedFd) -> Self {
        Self::from_inner(Dir(value))
    }
}