Deleted vendor folder

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)
-    })
-}