diff options
Diffstat (limited to 'vendor/rustix/src/fs/at.rs')
| -rw-r--r-- | vendor/rustix/src/fs/at.rs | 472 |
1 files changed, 0 insertions, 472 deletions
diff --git a/vendor/rustix/src/fs/at.rs b/vendor/rustix/src/fs/at.rs deleted file mode 100644 index 4163692..0000000 --- a/vendor/rustix/src/fs/at.rs +++ /dev/null @@ -1,472 +0,0 @@ -//! POSIX-style `*at` functions. -//! -//! The `dirfd` argument to these functions may be a file descriptor for a -//! directory, or the special value [`CWD`]. -//! -//! [`cwd`]: crate::fs::CWD - -use crate::fd::OwnedFd; -use crate::ffi::CStr; -#[cfg(not(any(target_os = "espidf", target_os = "vita")))] -use crate::fs::Access; -#[cfg(not(target_os = "espidf"))] -use crate::fs::AtFlags; -#[cfg(apple)] -use crate::fs::CloneFlags; -#[cfg(linux_kernel)] -use crate::fs::RenameFlags; -#[cfg(not(target_os = "espidf"))] -use crate::fs::Stat; -#[cfg(not(any(apple, target_os = "espidf", target_os = "vita", target_os = "wasi")))] -use crate::fs::{Dev, FileType}; -#[cfg(not(any(target_os = "espidf", target_os = "wasi")))] -use crate::fs::{Gid, Uid}; -use crate::fs::{Mode, OFlags}; -use crate::{backend, io, path}; -use backend::fd::{AsFd, BorrowedFd}; -use core::mem::MaybeUninit; -use core::slice; -#[cfg(feature = "alloc")] -use {crate::ffi::CString, crate::path::SMALL_PATH_BUFFER_SIZE, alloc::vec::Vec}; -#[cfg(not(any(target_os = "espidf", target_os = "vita")))] -use {crate::fs::Timestamps, crate::timespec::Nsecs}; - -/// `UTIME_NOW` for use with [`utimensat`]. -/// -/// [`utimensat`]: crate::fs::utimensat -#[cfg(not(any(target_os = "espidf", target_os = "redox", target_os = "vita")))] -pub const UTIME_NOW: Nsecs = backend::c::UTIME_NOW as Nsecs; - -/// `UTIME_OMIT` for use with [`utimensat`]. -/// -/// [`utimensat`]: crate::fs::utimensat -#[cfg(not(any(target_os = "espidf", target_os = "redox", target_os = "vita")))] -pub const UTIME_OMIT: Nsecs = backend::c::UTIME_OMIT as Nsecs; - -/// `openat(dirfd, path, oflags, mode)`—Opens a file. -/// -/// POSIX guarantees that `openat` will use the lowest unused file descriptor, -/// however it is not safe in general to rely on this, as file descriptors may -/// be unexpectedly allocated on other threads or in libraries. -/// -/// The `Mode` argument is only significant when creating a file. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/openat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/openat.2.html -#[inline] -pub fn openat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - oflags: OFlags, - create_mode: Mode, -) -> io::Result<OwnedFd> { - path.into_with_c_str(|path| { - backend::fs::syscalls::openat(dirfd.as_fd(), path, oflags, create_mode) - }) -} - -/// `readlinkat(fd, path)`—Reads the contents of a symlink. -/// -/// If `reuse` already has available capacity, reuse it if possible. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlinkat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/readlinkat.2.html -#[cfg(feature = "alloc")] -#[inline] -pub fn readlinkat<P: path::Arg, Fd: AsFd, B: Into<Vec<u8>>>( - dirfd: Fd, - path: P, - reuse: B, -) -> io::Result<CString> { - path.into_with_c_str(|path| _readlinkat(dirfd.as_fd(), path, reuse.into())) -} - -#[cfg(feature = "alloc")] -#[allow(unsafe_code)] -fn _readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, mut buffer: Vec<u8>) -> io::Result<CString> { - buffer.clear(); - buffer.reserve(SMALL_PATH_BUFFER_SIZE); - - loop { - let nread = - backend::fs::syscalls::readlinkat(dirfd.as_fd(), path, buffer.spare_capacity_mut())?; - - debug_assert!(nread <= buffer.capacity()); - if nread < buffer.capacity() { - // SAFETY: From the [documentation]: “On success, these calls - // return the number of bytes placed in buf.” - // - // [documentation]: https://man7.org/linux/man-pages/man2/readlinkat.2.html - unsafe { - buffer.set_len(nread); - } - - // SAFETY: - // - “readlink places the contents of the symbolic link pathname in - // the buffer buf” - // - [POSIX definition 3.271: Pathname]: “A string that is used to - // identify a file.” - // - [POSIX definition 3.375: String]: “A contiguous sequence of - // bytes terminated by and including the first null byte.” - // - “readlink does not append a terminating null byte to buf.” - // - // Thus, there will be no NUL bytes in the string. - // - // [POSIX definition 3.271: Pathname]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_271 - // [POSIX definition 3.375: String]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_375 - unsafe { - return Ok(CString::from_vec_unchecked(buffer)); - } - } - - // Use `Vec` reallocation strategy to grow capacity exponentially. - buffer.reserve(buffer.capacity() + 1); - } -} - -/// `readlinkat(fd, path)`—Reads the contents of a symlink, without -/// allocating. -/// -/// This is the "raw" version which avoids allocating, but which is -/// significantly trickier to use; most users should use plain [`readlinkat`]. -/// -/// This version writes bytes into the buffer and returns two slices, one -/// containing the written bytes, and one containint the remaining -/// uninitialized space. If the number of written bytes is equal to the length -/// of the buffer, it means the buffer wasn't big enough to hold the full -/// string, and callers should try again with a bigger buffer. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlinkat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/readlinkat.2.html -#[inline] -pub fn readlinkat_raw<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - buf: &mut [MaybeUninit<u8>], -) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>])> { - path.into_with_c_str(|path| _readlinkat_raw(dirfd.as_fd(), path, buf)) -} - -#[allow(unsafe_code)] -fn _readlinkat_raw<'a>( - dirfd: BorrowedFd<'_>, - path: &CStr, - buf: &'a mut [MaybeUninit<u8>], -) -> io::Result<(&'a mut [u8], &'a mut [MaybeUninit<u8>])> { - let n = backend::fs::syscalls::readlinkat(dirfd.as_fd(), path, buf)?; - unsafe { - Ok(( - slice::from_raw_parts_mut(buf.as_mut_ptr().cast::<u8>(), n), - &mut buf[n..], - )) - } -} - -/// `mkdirat(fd, path, mode)`—Creates a directory. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdirat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/mkdirat.2.html -#[inline] -pub fn mkdirat<P: path::Arg, Fd: AsFd>(dirfd: Fd, path: P, mode: Mode) -> io::Result<()> { - path.into_with_c_str(|path| backend::fs::syscalls::mkdirat(dirfd.as_fd(), path, mode)) -} - -/// `linkat(old_dirfd, old_path, new_dirfd, new_path, flags)`—Creates a hard -/// link. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/linkat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/linkat.2.html -#[cfg(not(target_os = "espidf"))] -#[inline] -pub fn linkat<P: path::Arg, Q: path::Arg, PFd: AsFd, QFd: AsFd>( - old_dirfd: PFd, - old_path: P, - new_dirfd: QFd, - new_path: Q, - flags: AtFlags, -) -> io::Result<()> { - old_path.into_with_c_str(|old_path| { - new_path.into_with_c_str(|new_path| { - backend::fs::syscalls::linkat( - old_dirfd.as_fd(), - old_path, - new_dirfd.as_fd(), - new_path, - flags, - ) - }) - }) -} - -/// `unlinkat(fd, path, flags)`—Unlinks a file or remove a directory. -/// -/// With the [`REMOVEDIR`] flag, this removes a directory. This is in place of -/// a `rmdirat` function. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [`REMOVEDIR`]: AtFlags::REMOVEDIR -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlinkat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/unlinkat.2.html -#[cfg(not(target_os = "espidf"))] -#[inline] -pub fn unlinkat<P: path::Arg, Fd: AsFd>(dirfd: Fd, path: P, flags: AtFlags) -> io::Result<()> { - path.into_with_c_str(|path| backend::fs::syscalls::unlinkat(dirfd.as_fd(), path, flags)) -} - -/// `renameat(old_dirfd, old_path, new_dirfd, new_path)`—Renames a file or -/// directory. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/renameat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/renameat.2.html -#[inline] -pub fn renameat<P: path::Arg, Q: path::Arg, PFd: AsFd, QFd: AsFd>( - old_dirfd: PFd, - old_path: P, - new_dirfd: QFd, - new_path: Q, -) -> io::Result<()> { - old_path.into_with_c_str(|old_path| { - new_path.into_with_c_str(|new_path| { - backend::fs::syscalls::renameat( - old_dirfd.as_fd(), - old_path, - new_dirfd.as_fd(), - new_path, - ) - }) - }) -} - -/// `renameat2(old_dirfd, old_path, new_dirfd, new_path, flags)`—Renames a -/// file or directory. -/// -/// # References -/// - [Linux] -/// -/// [Linux]: https://man7.org/linux/man-pages/man2/renameat2.2.html -#[cfg(linux_kernel)] -#[inline] -#[doc(alias = "renameat2")] -pub fn renameat_with<P: path::Arg, Q: path::Arg, PFd: AsFd, QFd: AsFd>( - old_dirfd: PFd, - old_path: P, - new_dirfd: QFd, - new_path: Q, - flags: RenameFlags, -) -> io::Result<()> { - old_path.into_with_c_str(|old_path| { - new_path.into_with_c_str(|new_path| { - backend::fs::syscalls::renameat2( - old_dirfd.as_fd(), - old_path, - new_dirfd.as_fd(), - new_path, - flags, - ) - }) - }) -} - -/// `symlinkat(old_path, new_dirfd, new_path)`—Creates a symlink. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/symlinkat.2.html -#[inline] -pub fn symlinkat<P: path::Arg, Q: path::Arg, Fd: AsFd>( - old_path: P, - new_dirfd: Fd, - new_path: Q, -) -> io::Result<()> { - old_path.into_with_c_str(|old_path| { - new_path.into_with_c_str(|new_path| { - backend::fs::syscalls::symlinkat(old_path, new_dirfd.as_fd(), new_path) - }) - }) -} - -/// `fstatat(dirfd, path, flags)`—Queries metadata for a file or directory. -/// -/// [`Mode::from_raw_mode`] and [`FileType::from_raw_mode`] may be used to -/// interpret the `st_mode` field. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/fstatat.2.html -/// [`Mode::from_raw_mode`]: crate::fs::Mode::from_raw_mode -/// [`FileType::from_raw_mode`]: crate::fs::FileType::from_raw_mode -#[cfg(not(target_os = "espidf"))] -#[inline] -#[doc(alias = "fstatat")] -pub fn statat<P: path::Arg, Fd: AsFd>(dirfd: Fd, path: P, flags: AtFlags) -> io::Result<Stat> { - path.into_with_c_str(|path| backend::fs::syscalls::statat(dirfd.as_fd(), path, flags)) -} - -/// `faccessat(dirfd, path, access, flags)`—Tests permissions for a file or -/// directory. -/// -/// On Linux before 5.8, this function uses the `faccessat` system call which -/// doesn't support any flags. This function emulates support for the -/// [`AtFlags::EACCESS`] flag by checking whether the uid and gid of the -/// process match the effective uid and gid, in which case the `EACCESS` flag -/// can be ignored. In Linux 5.8 and beyond `faccessat2` is used, which -/// supports flags. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/faccessat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/faccessat.2.html -#[cfg(not(any(target_os = "espidf", target_os = "vita")))] -#[inline] -#[doc(alias = "faccessat")] -pub fn accessat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - access: Access, - flags: AtFlags, -) -> io::Result<()> { - path.into_with_c_str(|path| backend::fs::syscalls::accessat(dirfd.as_fd(), path, access, flags)) -} - -/// `utimensat(dirfd, path, times, flags)`—Sets file or directory timestamps. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimensat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/utimensat.2.html -#[cfg(not(any(target_os = "espidf", target_os = "vita")))] -#[inline] -pub fn utimensat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - times: &Timestamps, - flags: AtFlags, -) -> io::Result<()> { - path.into_with_c_str(|path| backend::fs::syscalls::utimensat(dirfd.as_fd(), path, times, flags)) -} - -/// `fchmodat(dirfd, path, mode, flags)`—Sets file or directory permissions. -/// -/// Platform support for flags varies widely, for example on Linux -/// [`AtFlags::SYMLINK_NOFOLLOW`] is not implemented and therefore -/// [`io::Errno::OPNOTSUPP`] will be returned. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmodat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/fchmodat.2.html -#[cfg(not(any(target_os = "espidf", target_os = "wasi")))] -#[inline] -#[doc(alias = "fchmodat")] -pub fn chmodat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - mode: Mode, - flags: AtFlags, -) -> io::Result<()> { - path.into_with_c_str(|path| backend::fs::syscalls::chmodat(dirfd.as_fd(), path, mode, flags)) -} - -/// `fclonefileat(src, dst_dir, dst, flags)`—Efficiently copies between files. -/// -/// # References -/// - [Apple] -/// -/// [Apple]: https://opensource.apple.com/source/xnu/xnu-3789.21.4/bsd/man/man2/clonefile.2.auto.html -#[cfg(apple)] -#[inline] -pub fn fclonefileat<Fd: AsFd, DstFd: AsFd, P: path::Arg>( - src: Fd, - dst_dir: DstFd, - dst: P, - flags: CloneFlags, -) -> io::Result<()> { - dst.into_with_c_str(|dst| { - backend::fs::syscalls::fclonefileat(src.as_fd(), dst_dir.as_fd(), dst, flags) - }) -} - -/// `mknodat(dirfd, path, mode, dev)`—Creates special or normal files. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mknodat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/mknodat.2.html -#[cfg(not(any(apple, target_os = "espidf", target_os = "vita", target_os = "wasi")))] -#[inline] -pub fn mknodat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - file_type: FileType, - mode: Mode, - dev: Dev, -) -> io::Result<()> { - path.into_with_c_str(|path| { - backend::fs::syscalls::mknodat(dirfd.as_fd(), path, file_type, mode, dev) - }) -} - -/// `fchownat(dirfd, path, owner, group, flags)`—Sets file or directory -/// ownership. -/// -/// # References -/// - [POSIX] -/// - [Linux] -/// -/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchownat.html -/// [Linux]: https://man7.org/linux/man-pages/man2/fchownat.2.html -#[cfg(not(any(target_os = "espidf", target_os = "wasi")))] -#[inline] -#[doc(alias = "fchownat")] -pub fn chownat<P: path::Arg, Fd: AsFd>( - dirfd: Fd, - path: P, - owner: Option<Uid>, - group: Option<Gid>, - flags: AtFlags, -) -> io::Result<()> { - path.into_with_c_str(|path| { - backend::fs::syscalls::chownat(dirfd.as_fd(), path, owner, group, flags) - }) -} |