diff options
Diffstat (limited to 'vendor/rustix/tests')
75 files changed, 4937 insertions, 0 deletions
diff --git a/vendor/rustix/tests/backends.rs b/vendor/rustix/tests/backends.rs new file mode 100644 index 000000000..4b88bd11c --- /dev/null +++ b/vendor/rustix/tests/backends.rs @@ -0,0 +1,109 @@ +use std::process::Command; + +#[test] +fn test_backends() { + // Pick an arbitrary platform where linux_raw is enabled by default and + // ensure that the use-default crate uses it. + #[cfg(all(target_os = "linux", target_arch = "aarch64"))] + { + assert!( + !has_dependency("test-crates/use-default", &[], &[], &["RUSTFLAGS"], "libc"), + "use-default depends on libc" + ); + assert!( + has_dependency( + "test-crates/use-default", + &[], + &[], + &["RUSTFLAGS"], + "linux-raw-sys" + ), + "use-default does not depend on linux-raw-sys" + ); + } + + #[cfg(windows)] + let libc_dep = "windows-sys"; + #[cfg(unix)] + let libc_dep = "libc"; + + // Test the use-libc crate, which enables the "use-libc" cargo feature. + assert!( + has_dependency("test-crates/use-libc", &[], &[], &["RUSTFLAGS"], libc_dep), + "use-libc doesn't depend on {}", + libc_dep + ); + + // Test the use-default crate with `--cfg=rustix_use_libc`. + assert!( + has_dependency( + "test-crates/use-default", + &[], + &[("RUSTFLAGS", "--cfg=rustix_use_libc")], + &[], + libc_dep + ), + "use-default with --cfg=rustix_use_libc does not depend on {}", + libc_dep + ); + assert!( + !has_dependency( + "test-crates/use-default", + &[], + &[("RUSTFLAGS", "--cfg=rustix_use_libc")], + &[], + "linux-raw-sys" + ), + "use-default with --cfg=rustix_use_libc depends on linux-raw-sys" + ); + + // Test the use-default crate with `--features=rustix/use-libc`. + assert!( + has_dependency( + "test-crates/use-default", + &["--features=rustix/use-libc"], + &[], + &[], + libc_dep + ), + "use-default with --features=rustix/use-libc does not depend on {}", + libc_dep + ); +} + +/// Test whether the crate at directory `dir` has a dependency on `dependency`, +/// setting the environment variables `envs` and unsetting the environment +/// variables `remove_envs` when running `cargo`. +fn has_dependency( + dir: &str, + args: &[&str], + envs: &[(&str, &str)], + remove_envs: &[&str], + dependency: &str, +) -> bool { + let mut command = Command::new("cargo"); + + command + .arg("tree") + .arg("--quiet") + .arg("--edges=normal") + .arg(&format!("--invert={}", dependency)) + .current_dir(dir); + + command.args(args); + for (key, value) in envs { + command.env(key, value); + } + for key in remove_envs { + command.env_remove(key); + } + + let child = command.output().unwrap(); + + // `cargo tree --invert=foo` can fail in two different ways: it exits with + // a non-zero status if the dependency is not present in the Cargo.toml + // configuration, and it exists with a zero status and prints nothing if + // the dependency is present but optional and not enabled. So we check for + // both here. + child.status.success() && !child.stdout.is_empty() +} diff --git a/vendor/rustix/tests/fs/cwd.rs b/vendor/rustix/tests/fs/cwd.rs new file mode 100644 index 000000000..749c84f24 --- /dev/null +++ b/vendor/rustix/tests/fs/cwd.rs @@ -0,0 +1,3 @@ +/// Make sure we can use `cwd` in const contexts. +#[allow(dead_code)] +const CWD: rustix::fd::BorrowedFd<'static> = rustix::fs::cwd(); diff --git a/vendor/rustix/tests/fs/dir.rs b/vendor/rustix/tests/fs/dir.rs new file mode 100644 index 000000000..f5120be96 --- /dev/null +++ b/vendor/rustix/tests/fs/dir.rs @@ -0,0 +1,37 @@ +#[test] +fn test_dir() { + let t = rustix::fs::openat( + rustix::fs::cwd(), + rustix::cstr!("."), + rustix::fs::OFlags::RDONLY | rustix::fs::OFlags::CLOEXEC, + rustix::fs::Mode::empty(), + ) + .unwrap(); + + let dir = rustix::fs::Dir::read_from(&t).unwrap(); + + let _file = rustix::fs::openat( + &t, + rustix::cstr!("Cargo.toml"), + rustix::fs::OFlags::RDONLY | rustix::fs::OFlags::CLOEXEC, + rustix::fs::Mode::empty(), + ) + .unwrap(); + + let mut saw_dot = false; + let mut saw_dotdot = false; + let mut saw_cargo_toml = false; + for entry in dir { + let entry = entry.unwrap(); + if entry.file_name() == rustix::cstr!(".") { + saw_dot = true; + } else if entry.file_name() == rustix::cstr!("..") { + saw_dotdot = true; + } else if entry.file_name() == rustix::cstr!("Cargo.toml") { + saw_cargo_toml = true; + } + } + assert!(saw_dot); + assert!(saw_dotdot); + assert!(saw_cargo_toml); +} diff --git a/vendor/rustix/tests/fs/fcntl.rs b/vendor/rustix/tests/fs/fcntl.rs new file mode 100644 index 000000000..1f8b78387 --- /dev/null +++ b/vendor/rustix/tests/fs/fcntl.rs @@ -0,0 +1,17 @@ +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_fcntl_dupfd_cloexec() { + use rustix::fd::AsFd; + use std::os::unix::io::AsRawFd; + + let file = rustix::fs::openat( + rustix::fs::cwd(), + "Cargo.toml", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .unwrap(); + + let new = rustix::fs::fcntl_dupfd_cloexec(&file, 700).unwrap(); + assert_eq!(new.as_fd().as_raw_fd(), 700); +} diff --git a/vendor/rustix/tests/fs/file.rs b/vendor/rustix/tests/fs/file.rs new file mode 100644 index 000000000..5c09f640d --- /dev/null +++ b/vendor/rustix/tests/fs/file.rs @@ -0,0 +1,83 @@ +#[cfg(not(target_os = "redox"))] +#[test] +fn test_file() { + #[cfg(not(target_os = "illumos"))] + rustix::fs::accessat( + rustix::fs::cwd(), + "Cargo.toml", + rustix::fs::Access::READ_OK, + rustix::fs::AtFlags::empty(), + ) + .unwrap(); + + assert_eq!( + rustix::fs::openat( + rustix::fs::cwd(), + "Cagro.motl", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .unwrap_err(), + rustix::io::Errno::NOENT + ); + + let file = rustix::fs::openat( + rustix::fs::cwd(), + "Cargo.toml", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .unwrap(); + + assert_eq!( + rustix::fs::openat( + &file, + "Cargo.toml", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .unwrap_err(), + rustix::io::Errno::NOTDIR + ); + + #[cfg(not(any( + target_os = "dragonfly", + target_os = "illumos", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + target_os = "redox", + )))] + rustix::fs::fadvise(&file, 0, 10, rustix::fs::Advice::Normal).unwrap(); + + assert_eq!( + rustix::fs::fcntl_getfd(&file).unwrap(), + rustix::fs::FdFlags::empty() + ); + assert_eq!( + rustix::fs::fcntl_getfl(&file).unwrap(), + rustix::fs::OFlags::empty() + ); + + let stat = rustix::fs::fstat(&file).unwrap(); + assert!(stat.st_size > 0); + assert!(stat.st_blocks > 0); + + #[cfg(not(any( + target_os = "illumos", + target_os = "netbsd", + target_os = "redox", + target_os = "wasi", + )))] + // not implemented in libc for netbsd yet + { + let statfs = rustix::fs::fstatfs(&file).unwrap(); + assert!(statfs.f_blocks > 0); + } + + #[cfg(feature = "net")] + assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false)); + + assert_ne!(rustix::io::ioctl_fionread(&file).unwrap(), 0); +} diff --git a/vendor/rustix/tests/fs/flock.rs b/vendor/rustix/tests/fs/flock.rs new file mode 100644 index 000000000..1b7df6ffd --- /dev/null +++ b/vendor/rustix/tests/fs/flock.rs @@ -0,0 +1,34 @@ +#[cfg(not(target_os = "redox"))] +#[test] +fn test_flock() { + use rustix::fs::{cwd, flock, openat, FlockOperation, Mode, OFlags}; + + let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&f, FlockOperation::LockExclusive).unwrap(); + flock(&f, FlockOperation::Unlock).unwrap(); + let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&g, FlockOperation::LockExclusive).unwrap(); + flock(&g, FlockOperation::Unlock).unwrap(); + drop(f); + drop(g); + + let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&f, FlockOperation::LockShared).unwrap(); + let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&g, FlockOperation::LockShared).unwrap(); + flock(&f, FlockOperation::Unlock).unwrap(); + flock(&g, FlockOperation::Unlock).unwrap(); + drop(f); + drop(g); + + let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&f, FlockOperation::LockShared).unwrap(); + flock(&f, FlockOperation::LockExclusive).unwrap(); + flock(&f, FlockOperation::Unlock).unwrap(); + let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); + flock(&g, FlockOperation::LockShared).unwrap(); + flock(&g, FlockOperation::LockExclusive).unwrap(); + flock(&g, FlockOperation::Unlock).unwrap(); + drop(f); + drop(g); +} diff --git a/vendor/rustix/tests/fs/futimens.rs b/vendor/rustix/tests/fs/futimens.rs new file mode 100644 index 000000000..81f8b8a27 --- /dev/null +++ b/vendor/rustix/tests/fs/futimens.rs @@ -0,0 +1,42 @@ +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_futimens() { + use rustix::fs::{cwd, fstat, futimens, openat, Mode, OFlags, Timespec, Timestamps}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + let foo = openat( + &dir, + "foo", + OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let times = Timestamps { + last_access: Timespec { + tv_sec: 44000, + tv_nsec: 45000, + }, + last_modification: Timespec { + tv_sec: 46000, + tv_nsec: 47000, + }, + }; + futimens(&foo, ×).unwrap(); + + let after = fstat(&foo).unwrap(); + + assert_eq!(times.last_modification.tv_sec as u64, after.st_mtime as u64); + #[cfg(not(target_os = "netbsd"))] + assert_eq!( + times.last_modification.tv_nsec as u64, + after.st_mtime_nsec as u64 + ); + #[cfg(target_os = "netbsd")] + assert_eq!( + times.last_modification.tv_nsec as u64, + after.st_mtimensec as u64 + ); +} diff --git a/vendor/rustix/tests/fs/invalid_offset.rs b/vendor/rustix/tests/fs/invalid_offset.rs new file mode 100644 index 000000000..995e302a1 --- /dev/null +++ b/vendor/rustix/tests/fs/invalid_offset.rs @@ -0,0 +1,182 @@ +//! Tests for extreme `u64` file offsets. +//! +//! POSIX-ish interfaces tend to use signed integers for file offsets, while +//! Rust APIs tend to use `u64`. Test that extreme `u64` values in APIs that +//! take file offsets are properly diagnosed. +//! +//! These tests are disabled on ios/macos since those platforms kill the +//! process with `SIGXFSZ` instead of returning an error. + +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] + +use rustix::io::SeekFrom; + +#[test] +fn invalid_offset_seek() { + use rustix::fs::{cwd, openat, seek, Mode, OFlags}; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let file = openat( + &dir, + "foo", + OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + seek(&file, SeekFrom::Start(u64::MAX)).unwrap_err(); + seek(&file, SeekFrom::Start(i64::MAX as u64 + 1)).unwrap_err(); + seek(&file, SeekFrom::End(-1)).unwrap_err(); + seek(&file, SeekFrom::End(i64::MIN)).unwrap_err(); + seek(&file, SeekFrom::Current(-1)).unwrap_err(); + seek(&file, SeekFrom::Current(i64::MIN)).unwrap_err(); +} + +#[cfg(not(any( + target_os = "dragonfly", + target_os = "illumos", + target_os = "netbsd", + target_os = "openbsd", + target_os = "redox", +)))] +#[test] +fn invalid_offset_fallocate() { + use rustix::fs::{cwd, fallocate, openat, FallocateFlags, Mode, OFlags}; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let file = openat( + &dir, + "foo", + OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + fallocate(&file, FallocateFlags::empty(), u64::MAX, 1).unwrap_err(); + fallocate(&file, FallocateFlags::empty(), i64::MAX as u64 + 1, 1).unwrap_err(); + fallocate(&file, FallocateFlags::empty(), 0, u64::MAX).unwrap_err(); + fallocate(&file, FallocateFlags::empty(), 0, i64::MAX as u64 + 1).unwrap_err(); +} + +#[cfg(not(any( + target_os = "dragonfly", + target_os = "illumos", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + target_os = "redox", +)))] +#[test] +fn invalid_offset_fadvise() { + use rustix::fs::{cwd, fadvise, openat, Advice, Mode, OFlags}; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let file = openat( + &dir, + "foo", + OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + // `fadvise` never fails on invalid offsets. + fadvise(&file, i64::MAX as u64, i64::MAX as u64, Advice::Normal).unwrap(); + fadvise(&file, u64::MAX, 0, Advice::Normal).unwrap(); + fadvise(&file, i64::MAX as u64, 1, Advice::Normal).unwrap(); + fadvise(&file, 1, i64::MAX as u64, Advice::Normal).unwrap(); + fadvise(&file, i64::MAX as u64 + 1, 0, Advice::Normal).unwrap(); + fadvise(&file, u64::MAX, i64::MAX as u64, Advice::Normal).unwrap(); + + // `fadvise` fails on invalid lengths. + fadvise(&file, u64::MAX, u64::MAX, Advice::Normal).unwrap_err(); + fadvise(&file, i64::MAX as u64, u64::MAX, Advice::Normal).unwrap_err(); + fadvise(&file, 0, u64::MAX, Advice::Normal).unwrap_err(); + fadvise(&file, u64::MAX, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); + fadvise(&file, i64::MAX as u64 + 1, u64::MAX, Advice::Normal).unwrap_err(); + fadvise(&file, i64::MAX as u64, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); + fadvise(&file, 0, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); +} + +#[test] +fn invalid_offset_pread() { + use rustix::fs::{cwd, openat, Mode, OFlags}; + use rustix::io::pread; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let file = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + let mut buf = [0_u8; 1]; + pread(&file, &mut buf, u64::MAX).unwrap_err(); + pread(&file, &mut buf, i64::MAX as u64 + 1).unwrap_err(); +} + +#[cfg(not(any(target_os = "ios", target_os = "macos")))] +#[test] +fn invalid_offset_pwrite() { + use rustix::fs::{cwd, openat, Mode, OFlags}; + use rustix::io::pwrite; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let file = openat( + &dir, + "foo", + OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + let buf = [0_u8; 1]; + pwrite(&file, &buf, u64::MAX).unwrap_err(); + pwrite(&file, &buf, i64::MAX as u64 + 1).unwrap_err(); +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn invalid_offset_copy_file_range() { + use rustix::fs::{copy_file_range, cwd, openat, Mode, OFlags}; + use rustix::io::write; + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let foo = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + let bar = openat( + &dir, + "bar", + OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + write(&foo, b"a").unwrap(); + + let mut off_in = u64::MAX; + let mut off_out = 0; + copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); + + let mut off_in = i64::MAX as u64 + 1; + let mut off_out = 0; + copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); + + let mut off_in = 0; + let mut off_out = u64::MAX; + copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); + + let mut off_in = 0; + let mut off_out = i64::MAX as u64; + copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); + + let mut off_in = 0; + let mut off_out = i64::MAX as u64 + 1; + copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); +} diff --git a/vendor/rustix/tests/fs/long_paths.rs b/vendor/rustix/tests/fs/long_paths.rs new file mode 100644 index 000000000..dbc2fa6ea --- /dev/null +++ b/vendor/rustix/tests/fs/long_paths.rs @@ -0,0 +1,28 @@ +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_long_paths() { + use rustix::fs::{cwd, mkdirat, openat, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + #[cfg(libc)] + const PATH_MAX: usize = libc::PATH_MAX as usize; + #[cfg(linux_raw)] + const PATH_MAX: usize = linux_raw_sys::general::PATH_MAX as usize; + + mkdirat(&dir, "a", Mode::RUSR | Mode::XUSR | Mode::WUSR).unwrap(); + + let mut long_path = String::new(); + for _ in 0..PATH_MAX / 5 { + long_path.push_str("a/../"); + } + + let mut too_long_path = String::new(); + for _ in 0..PATH_MAX / 4 { + too_long_path.push_str("a/../"); + } + + let _ = openat(&dir, &long_path, OFlags::RDONLY, Mode::empty()).unwrap(); + let _ = openat(&dir, &too_long_path, OFlags::RDONLY, Mode::empty()).unwrap_err(); +} diff --git a/vendor/rustix/tests/fs/main.rs b/vendor/rustix/tests/fs/main.rs new file mode 100644 index 000000000..23928a6ba --- /dev/null +++ b/vendor/rustix/tests/fs/main.rs @@ -0,0 +1,47 @@ +//! Tests for [`rustix::fs`]. + +#![cfg(feature = "fs")] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg_attr(core_c_str, feature(core_c_str))] + +mod cwd; +mod dir; +mod fcntl; +mod file; +#[cfg(not(target_os = "wasi"))] +mod flock; +mod futimens; +mod invalid_offset; +mod long_paths; +#[cfg(not(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "illumos", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +mod makedev; +mod mkdirat; +mod mknodat; +#[cfg(any(target_os = "android", target_os = "linux"))] +mod openat; +#[cfg(any(target_os = "android", target_os = "linux"))] +mod openat2; +mod readdir; +mod renameat; +#[cfg(not(any( + target_os = "illumos", + target_os = "netbsd", + target_os = "redox", + target_os = "wasi", +)))] +// not implemented in libc for netbsd yet +mod statfs; +mod utimensat; +mod y2038; diff --git a/vendor/rustix/tests/fs/makedev.rs b/vendor/rustix/tests/fs/makedev.rs new file mode 100644 index 000000000..79b5199e8 --- /dev/null +++ b/vendor/rustix/tests/fs/makedev.rs @@ -0,0 +1,10 @@ +use rustix::fs::{major, makedev, minor}; + +#[test] +fn makedev_roundtrip() { + let maj = 0x2324_2526; + let min = 0x6564_6361; + let dev = makedev(maj, min); + assert_eq!(maj, major(dev)); + assert_eq!(min, minor(dev)); +} diff --git a/vendor/rustix/tests/fs/mkdirat.rs b/vendor/rustix/tests/fs/mkdirat.rs new file mode 100644 index 000000000..884588037 --- /dev/null +++ b/vendor/rustix/tests/fs/mkdirat.rs @@ -0,0 +1,33 @@ +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_mkdirat() { + use rustix::fs::{cwd, mkdirat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + mkdirat(&dir, "foo", Mode::RWXU).unwrap(); + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Directory); + unlinkat(&dir, "foo", AtFlags::REMOVEDIR).unwrap(); +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_mkdirat_with_o_path() { + use rustix::fs::{cwd, mkdirat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::PATH, + Mode::empty(), + ) + .unwrap(); + + mkdirat(&dir, "foo", Mode::RWXU).unwrap(); + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Directory); + unlinkat(&dir, "foo", AtFlags::REMOVEDIR).unwrap(); +} diff --git a/vendor/rustix/tests/fs/mknodat.rs b/vendor/rustix/tests/fs/mknodat.rs new file mode 100644 index 000000000..fa1c84f69 --- /dev/null +++ b/vendor/rustix/tests/fs/mknodat.rs @@ -0,0 +1,27 @@ +#[cfg(not(any( + target_os = "ios", + target_os = "macos", + target_os = "redox", + target_os = "wasi", +)))] +#[test] +fn test_mknodat() { + use rustix::fs::{cwd, mknodat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + // Create a regular file. Not supported on FreeBSD or OpenBSD. + #[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))] + { + mknodat(&dir, "foo", FileType::RegularFile, Mode::empty(), 0).unwrap(); + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::RegularFile); + unlinkat(&dir, "foo", AtFlags::empty()).unwrap(); + } + + mknodat(&dir, "foo", FileType::Fifo, Mode::empty(), 0).unwrap(); + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Fifo); + unlinkat(&dir, "foo", AtFlags::empty()).unwrap(); +} diff --git a/vendor/rustix/tests/fs/openat.rs b/vendor/rustix/tests/fs/openat.rs new file mode 100644 index 000000000..564574dc1 --- /dev/null +++ b/vendor/rustix/tests/fs/openat.rs @@ -0,0 +1,33 @@ +use std::fs::File; + +use io_lifetimes::{FromFd, IntoFd}; +use rustix::fs::{cwd, openat, Mode, OFlags}; +use std::io::Write; + +#[test] +fn test_openat_tmpfile() { + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + let f = match openat( + &dir, + ".", + OFlags::WRONLY | OFlags::CLOEXEC | OFlags::TMPFILE, + Mode::from_bits_truncate(0o644), + ) { + Ok(f) => Ok(Some(File::from_fd(f.into_fd()))), + // TODO: Factor out the `Err`, once we no longer support Rust 1.48. + Err(rustix::io::Errno::OPNOTSUPP) + | Err(rustix::io::Errno::ISDIR) + | Err(rustix::io::Errno::NOENT) => Ok(None), + Err(e) => Err(e), + }; + if let Some(mut f) = f.unwrap() { + write!(f, "hello world").unwrap(); + } +} diff --git a/vendor/rustix/tests/fs/openat2.rs b/vendor/rustix/tests/fs/openat2.rs new file mode 100644 index 000000000..0b1d86fe2 --- /dev/null +++ b/vendor/rustix/tests/fs/openat2.rs @@ -0,0 +1,184 @@ +use rustix::fd::AsFd; +use rustix::fs::{cwd, mkdirat, openat, openat2, symlinkat, Mode, OFlags, ResolveFlags}; +use rustix::io::OwnedFd; +use rustix::{io, path}; +use std::os::unix::io::AsRawFd; + +/// Like `openat2`, but keep retrying until it fails or succeeds. +fn openat2_more<Fd: AsFd, P: path::Arg>( + dirfd: Fd, + path: P, + oflags: OFlags, + mode: Mode, + resolve: ResolveFlags, +) -> io::Result<OwnedFd> { + let path = path.as_cow_c_str().unwrap().into_owned(); + loop { + match openat2(dirfd.as_fd(), &path, oflags, mode, resolve) { + Ok(file) => return Ok(file), + Err(io::Errno::AGAIN) => continue, + Err(err) => return Err(err), + } + } +} + +#[test] +fn test_openat2() { + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + // Detect whether `openat2` is available. + match openat2( + &dir, + ".", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) { + Ok(_file) => (), + Err(io::Errno::NOSYS) => return, + Err(_err) => return, + } + + // Create a file. + let _ = openat2_more( + &dir, + "test.txt", + OFlags::WRONLY | OFlags::CREATE | OFlags::TRUNC | OFlags::CLOEXEC, + Mode::RUSR, + ResolveFlags::empty(), + ) + .unwrap(); + + // Test `NO_SYMLINKS`. + symlinkat("test.txt", &dir, "symlink.txt").unwrap(); + let _ = openat2_more( + &dir, + "symlink.txt", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &dir, + "symlink.txt", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::NO_MAGICLINKS, + ) + .unwrap(); + let _ = openat2_more( + &dir, + "symlink.txt", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::NO_SYMLINKS, + ) + .unwrap_err(); + + // Test `NO_MAGICLINKS`. + let test = openat2_more( + &dir, + "test.txt", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &dir, + &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &dir, + &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::NO_SYMLINKS, + ) + .unwrap_err(); + let _ = openat2_more( + &dir, + &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::NO_MAGICLINKS, + ) + .unwrap_err(); + + // Test `NO_XDEV`. + let root = openat2_more( + &dir, + "/", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &root, + "proc", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &root, + "proc", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::NO_XDEV, + ) + .unwrap_err(); + + // Test `BENEATH`. + let _ = openat2_more( + &dir, + "..", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &dir, + "..", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::BENEATH, + ) + .unwrap_err(); + + // Test `IN_ROOT`. + let _ = openat2_more( + &dir, + "/proc", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::empty(), + ) + .unwrap(); + let _ = openat2_more( + &dir, + "/proc", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::IN_ROOT, + ) + .unwrap_err(); + mkdirat(&dir, "proc", Mode::RUSR | Mode::XUSR).unwrap(); + let _ = openat2_more( + &dir, + "/proc", + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ResolveFlags::IN_ROOT, + ) + .unwrap(); +} diff --git a/vendor/rustix/tests/fs/readdir.rs b/vendor/rustix/tests/fs/readdir.rs new file mode 100644 index 000000000..8925660a9 --- /dev/null +++ b/vendor/rustix/tests/fs/readdir.rs @@ -0,0 +1,68 @@ +#![cfg(not(target_os = "redox"))] + +use rustix::fs::{Dir, DirEntry}; +use std::collections::HashMap; + +#[test] +fn dir_entries() { + let tmpdir = tempfile::tempdir().expect("construct tempdir"); + let dirfd = std::fs::File::open(tmpdir.path()).expect("open tempdir as file"); + let mut dir = Dir::read_from(dirfd).expect("construct Dir from dirfd"); + + let entries = read_entries(&mut dir); + assert_eq!(entries.len(), 0, "no files in directory"); + + let _f1 = std::fs::File::create(tmpdir.path().join("file1")).expect("create file1"); + + let entries = read_entries(&mut dir); + assert!( + entries.get("file1").is_some(), + "directory contains `file1`: {:?}", + entries + ); + assert_eq!(entries.len(), 1); + + let _f2 = std::fs::File::create(tmpdir.path().join("file2")).expect("create file1"); + let entries = read_entries(&mut dir); + assert!( + entries.get("file1").is_some(), + "directory contains `file1`: {:?}", + entries + ); + assert!( + entries.get("file2").is_some(), + "directory contains `file2`: {:?}", + entries + ); + assert_eq!(entries.len(), 2); +} + +fn read_entries(dir: &mut Dir) -> HashMap<String, DirEntry> { + dir.rewind(); + let mut out = HashMap::new(); + loop { + match dir.read() { + Some(e) => { + let e = e.expect("non-error entry"); + let name = e.file_name().to_str().expect("utf8 filename").to_owned(); + if name != "." && name != ".." { + out.insert(name, e); + } + } + None => break, + } + } + out +} + +#[test] +fn dir_from_openat() { + let dirfd = rustix::fs::openat( + rustix::fs::cwd(), + ".", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .expect("open cwd as file"); + let _dir = Dir::read_from(dirfd).expect("construct Dir from dirfd"); +} diff --git a/vendor/rustix/tests/fs/renameat.rs b/vendor/rustix/tests/fs/renameat.rs new file mode 100644 index 000000000..2eea2e77a --- /dev/null +++ b/vendor/rustix/tests/fs/renameat.rs @@ -0,0 +1,104 @@ +#[cfg(any(target_os = "android", target_os = "linux"))] +use rustix::fs::Stat; + +#[cfg(any(target_os = "android", target_os = "linux"))] +fn same(a: &Stat, b: &Stat) -> bool { + a.st_ino == b.st_ino && a.st_dev == b.st_dev +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_renameat() { + use rustix::fs::{cwd, openat, renameat, statat, AtFlags, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::PATH, + Mode::empty(), + ) + .unwrap(); + + let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); + let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); + renameat(&dir, "foo", &dir, "bar").unwrap(); + let renamed = statat(&dir, "bar", AtFlags::empty()).unwrap(); + assert!(same(&before, &renamed)); +} + +/// Like `test_renameat` but the file already exists, so `renameat` +/// overwrites it. +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_renameat_overwrite() { + use rustix::fs::{cwd, openat, renameat, statat, AtFlags, Mode, OFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::PATH, + Mode::empty(), + ) + .unwrap(); + + let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); + let _ = openat(&dir, "bar", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); + let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); + renameat(&dir, "foo", &dir, "bar").unwrap(); + let renamed = statat(&dir, "bar", AtFlags::empty()).unwrap(); + assert!(same(&before, &renamed)); +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_renameat_with() { + use rustix::fs::{cwd, openat, renameat_with, statat, AtFlags, Mode, OFlags, RenameFlags}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::PATH, + Mode::empty(), + ) + .unwrap(); + + let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); + let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); + + match renameat_with(&dir, "foo", &dir, "red", RenameFlags::empty()) { + Ok(()) => (), + Err(e) if e == rustix::io::Errno::NOSYS => return, + Err(e) => unreachable!("unexpected error from renameat_with: {:?}", e), + } + + let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); + assert!(same(&before, &renamed)); + + let _ = openat( + &dir, + "green", + OFlags::CREATE | OFlags::WRONLY, + Mode::empty(), + ) + .unwrap(); + + #[cfg(all(target_os = "linux", target_env = "gnu"))] + { + let green = statat(&dir, "green", AtFlags::empty()).unwrap(); + + renameat_with(&dir, "red", &dir, "green", RenameFlags::NOREPLACE).unwrap_err(); + let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); + assert!(same(&before, &renamed)); + let orig = statat(&dir, "green", AtFlags::empty()).unwrap(); + assert!(same(&green, &orig)); + + renameat_with(&dir, "red", &dir, "green", RenameFlags::EXCHANGE).unwrap(); + let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); + assert!(same(&green, &renamed)); + let orig = statat(&dir, "green", AtFlags::empty()).unwrap(); + assert!(same(&before, &orig)); + } +} diff --git a/vendor/rustix/tests/fs/statfs.rs b/vendor/rustix/tests/fs/statfs.rs new file mode 100644 index 000000000..f8bf2e350 --- /dev/null +++ b/vendor/rustix/tests/fs/statfs.rs @@ -0,0 +1,49 @@ +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_statfs_abi() { + use rustix::fs::{FsWord, StatFs, NFS_SUPER_MAGIC, PROC_SUPER_MAGIC}; + + // Ensure these all have consistent types. + let t: StatFs = unsafe { std::mem::zeroed() }; + let _s: FsWord = t.f_type; + let _u: FsWord = PROC_SUPER_MAGIC; + let _v: FsWord = NFS_SUPER_MAGIC; + + // Ensure that after all the platform-specific dancing we have to do, this + // constant comes out with the correct value. + #[cfg(all(libc, not(target_env = "musl")))] + { + assert_eq!( + i128::from(PROC_SUPER_MAGIC), + i128::from(libc::PROC_SUPER_MAGIC) + ); + assert_eq!( + i128::from(NFS_SUPER_MAGIC), + i128::from(libc::NFS_SUPER_MAGIC) + ); + } + + #[cfg(linux_raw)] + { + assert_eq!( + i128::from(PROC_SUPER_MAGIC), + i128::from(linux_raw_sys::general::PROC_SUPER_MAGIC) + ); + assert_eq!( + i128::from(NFS_SUPER_MAGIC), + i128::from(linux_raw_sys::general::NFS_SUPER_MAGIC) + ); + } + + assert_eq!(PROC_SUPER_MAGIC, 0x0000_9fa0); + assert_eq!(NFS_SUPER_MAGIC, 0x0000_6969); +} + +#[test] +fn test_statfs() { + let statfs = rustix::fs::statfs("Cargo.toml").unwrap(); + let f_blocks = statfs.f_blocks; + assert_ne!(f_blocks, 0); + // Previously we checked f_files != 0 here, but at least btrfs doesn't set + // that. +} diff --git a/vendor/rustix/tests/fs/utimensat.rs b/vendor/rustix/tests/fs/utimensat.rs new file mode 100644 index 000000000..f0fb7e27b --- /dev/null +++ b/vendor/rustix/tests/fs/utimensat.rs @@ -0,0 +1,127 @@ +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_utimensat() { + use rustix::fs::{cwd, openat, statat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let _ = openat( + &dir, + "foo", + OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let times = Timestamps { + last_access: Timespec { + tv_sec: 44000, + tv_nsec: 45000, + }, + last_modification: Timespec { + tv_sec: 46000, + tv_nsec: 47000, + }, + }; + utimensat(&dir, "foo", ×, AtFlags::empty()).unwrap(); + + let after = statat(&dir, "foo", AtFlags::empty()).unwrap(); + + assert_eq!(times.last_modification.tv_sec as u64, after.st_mtime as u64); + #[cfg(not(target_os = "netbsd"))] + assert_eq!( + times.last_modification.tv_nsec as u64, + after.st_mtime_nsec as u64 + ); + #[cfg(target_os = "netbsd")] + assert_eq!( + times.last_modification.tv_nsec as u64, + after.st_mtimensec as u64 + ); + assert!(times.last_access.tv_sec as u64 >= after.st_atime as u64); + #[cfg(not(target_os = "netbsd"))] + assert!( + times.last_access.tv_sec as u64 > after.st_atime as u64 + || times.last_access.tv_nsec as u64 >= after.st_atime_nsec as u64 + ); + #[cfg(target_os = "netbsd")] + assert!( + times.last_access.tv_sec as u64 > after.st_atime as u64 + || times.last_access.tv_nsec as u64 >= after.st_atimensec as u64 + ); +} + +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_utimensat_noent() { + use rustix::fs::{cwd, openat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let times = Timestamps { + last_access: Timespec { + tv_sec: 44000, + tv_nsec: 45000, + }, + last_modification: Timespec { + tv_sec: 46000, + tv_nsec: 47000, + }, + }; + assert_eq!( + utimensat(&dir, "foo", ×, AtFlags::empty()).unwrap_err(), + rustix::io::Errno::NOENT + ); +} + +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +#[test] +fn test_utimensat_notdir() { + use rustix::fs::{cwd, openat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat( + cwd(), + tmp.path(), + OFlags::RDONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let foo = openat( + &dir, + "foo", + OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, + Mode::empty(), + ) + .unwrap(); + + let times = Timestamps { + last_access: Timespec { + tv_sec: 44000, + tv_nsec: 45000, + }, + last_modification: Timespec { + tv_sec: 46000, + tv_nsec: 47000, + }, + }; + assert_eq!( + utimensat(&foo, "bar", ×, AtFlags::empty()).unwrap_err(), + rustix::io::Errno::NOTDIR + ); +} diff --git a/vendor/rustix/tests/fs/y2038.rs b/vendor/rustix/tests/fs/y2038.rs new file mode 100644 index 000000000..4299d709b --- /dev/null +++ b/vendor/rustix/tests/fs/y2038.rs @@ -0,0 +1,146 @@ +/// Test that we can set a file timestamp to a date past the year 2038 with +/// `utimensat` and read it back again. +/// +/// See tests/time/y2038.rs for more information about y2038 testing. +#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] +#[test] +fn test_y2038_with_utimensat() { + use rustix::fs::{ + cwd, fstat, openat, statat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps, + }; + use std::convert::TryInto; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(&cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + let m_sec = 1_u64 << 32; + let m_nsec = 17_u32; + let a_sec = m_sec + 1; + let a_nsec = m_nsec + 1; + + let timestamps = Timestamps { + last_modification: Timespec { + tv_sec: m_sec as _, + tv_nsec: m_nsec as _, + }, + last_access: Timespec { + tv_sec: a_sec as _, + tv_nsec: a_nsec as _, + }, + }; + let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::RUSR).unwrap(); + + match utimensat(&dir, "foo", ×tamps, AtFlags::empty()) { + Ok(()) => (), + + // On 32-bit platforms, accept `EOVERFLOW`, meaning that y2038 support + // is not available in this version of the OS. + #[cfg(target_pointer_width = "32")] + Err(rustix::io::Errno::OVERFLOW) => return, + + Err(e) => panic!("unexpected error: {:?}", e), + } + + // Use `statat` to read back the timestamp. + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + + assert_eq!( + TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, + m_sec + ); + assert_eq!(stat.st_mtime_nsec as u32, m_nsec); + assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); + assert!( + TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec + || stat.st_atime_nsec as u32 >= a_nsec + ); + + // Now test the same thing, but with `fstat`. + let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); + let stat = fstat(&file).unwrap(); + + assert_eq!( + TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, + m_sec + ); + assert_eq!(stat.st_mtime_nsec as u32, m_nsec); + assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); + assert!( + TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec + || stat.st_atime_nsec as u32 >= a_nsec + ); +} + +/// Test that we can set a file timestamp to a date past the year 2038 with +/// `futimens` and read it back again. +/// +/// See tests/time/y2038.rs for more information about y2038 testing. +#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] +#[test] +fn test_y2038_with_futimens() { + use rustix::fs::{ + cwd, fstat, futimens, openat, statat, AtFlags, Mode, OFlags, Timespec, Timestamps, + }; + use std::convert::TryInto; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(&cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + let m_sec = 1_u64 << 32; + let m_nsec = 17_u32; + let a_sec = m_sec + 1; + let a_nsec = m_nsec + 1; + + let timestamps = Timestamps { + last_modification: Timespec { + tv_sec: m_sec as _, + tv_nsec: m_nsec as _, + }, + last_access: Timespec { + tv_sec: a_sec as _, + tv_nsec: a_nsec as _, + }, + }; + let file = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::RUSR).unwrap(); + + match futimens(&file, ×tamps) { + Ok(()) => (), + + // On 32-bit platforms, accept `EOVERFLOW`, meaning that y2038 support + // is not available in this version of the OS. + #[cfg(target_pointer_width = "32")] + Err(rustix::io::Errno::OVERFLOW) => return, + + Err(e) => panic!("unexpected error: {:?}", e), + } + + // Use `statat` to read back the timestamp. + let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); + + assert_eq!(TryInto::<u64>::try_into(stat.st_mtime).unwrap(), m_sec); + assert_eq!(stat.st_mtime_nsec as u32, m_nsec); + assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() >= a_sec); + assert!( + TryInto::<u64>::try_into(stat.st_atime).unwrap() > a_sec + || stat.st_atime_nsec as u32 >= a_nsec + ); + + // Now test the same thing, but with `fstat`. + let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); + let stat = fstat(&file).unwrap(); + + assert_eq!( + TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, + m_sec + ); + assert_eq!(stat.st_mtime_nsec as u32, m_nsec); + assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); + assert!( + TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec + || stat.st_atime_nsec as u32 >= a_nsec + ); +} diff --git a/vendor/rustix/tests/io/dup2_to_replace_stdio.rs b/vendor/rustix/tests/io/dup2_to_replace_stdio.rs new file mode 100644 index 000000000..b07ec17f0 --- /dev/null +++ b/vendor/rustix/tests/io/dup2_to_replace_stdio.rs @@ -0,0 +1,18 @@ +#![cfg(not(target_os = "wasi"))] + +use std::env; +use std::process::Command; + +/// Use `dup2` to replace the stdin and stdout file descriptors. +#[test] +fn dup2_to_replace_stdio() { + // This test modifies the stdio file descriptors, so we run it in a + // separate process so that it doesn't interfere with the test harness. + assert!(Command::new(env::var("CARGO").unwrap()) + .arg("run") + .arg("--example") + .arg("dup2_to_replace_stdio") + .status() + .unwrap() + .success()); +} diff --git a/vendor/rustix/tests/io/epoll.rs b/vendor/rustix/tests/io/epoll.rs new file mode 100644 index 000000000..4cfe305fe --- /dev/null +++ b/vendor/rustix/tests/io/epoll.rs @@ -0,0 +1,103 @@ +#![cfg(any(target_os = "android", target_os = "linux"))] + +use rustix::fd::AsFd; +use rustix::io::epoll::{self, Epoll}; +use rustix::io::{ioctl_fionbio, read, write, OwnedFd}; +use rustix::net::{ + accept, bind_v4, connect_v4, getsockname, listen, socket, AddressFamily, Ipv4Addr, Protocol, + SocketAddrAny, SocketAddrV4, SocketType, +}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; + +const BUFFER_SIZE: usize = 20; + +fn server(ready: Arc<(Mutex<u16>, Condvar)>) { + let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); + bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0)).unwrap(); + listen(&listen_sock, 1).unwrap(); + + let who = match getsockname(&listen_sock).unwrap() { + SocketAddrAny::V4(addr) => addr, + _ => panic!(), + }; + + { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + *port = who.port(); + cvar.notify_all(); + } + + let epoll = Epoll::new(epoll::CreateFlags::CLOEXEC, epoll::Owning::<OwnedFd>::new()).unwrap(); + + // Test into conversions. + let fd: OwnedFd = epoll.into(); + let epoll: Epoll<epoll::Owning<OwnedFd>> = fd.into(); + let fd: RawFd = epoll.into_raw_fd(); + let epoll = unsafe { Epoll::<epoll::Owning<OwnedFd>>::from_raw_fd(fd) }; + + let raw_listen_sock = listen_sock.as_fd().as_raw_fd(); + epoll.add(listen_sock, epoll::EventFlags::IN).unwrap(); + + let mut event_list = epoll::EventVec::with_capacity(4); + loop { + epoll.wait(&mut event_list, -1).unwrap(); + for (_event_flags, target) in &event_list { + if target.as_raw_fd() == raw_listen_sock { + let conn_sock = accept(&*target).unwrap(); + ioctl_fionbio(&conn_sock, true).unwrap(); + epoll + .add(conn_sock, epoll::EventFlags::OUT | epoll::EventFlags::ET) + .unwrap(); + } else { + write(&*target, b"hello\n").unwrap(); + let _ = epoll.del(target).unwrap(); + } + } + } +} + +fn client(ready: Arc<(Mutex<u16>, Condvar)>) { + let port = { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + while *port == 0 { + port = cvar.wait(port).unwrap(); + } + *port + }; + + let addr = SocketAddrV4::new(Ipv4Addr::LOCALHOST, port); + let mut buffer = vec![0; BUFFER_SIZE]; + + for _ in 0..16 { + let data_socket = + socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); + connect_v4(&data_socket, &addr).unwrap(); + + let nread = read(&data_socket, &mut buffer).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello\n"); + } +} + +#[test] +fn test_epoll() { + let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); + let ready_clone = Arc::clone(&ready); + + let _server = thread::Builder::new() + .name("server".to_string()) + .spawn(move || { + server(ready); + }) + .unwrap(); + let client = thread::Builder::new() + .name("client".to_string()) + .spawn(move || { + client(ready_clone); + }) + .unwrap(); + client.join().unwrap(); +} diff --git a/vendor/rustix/tests/io/error.rs b/vendor/rustix/tests/io/error.rs new file mode 100644 index 000000000..128d3b59a --- /dev/null +++ b/vendor/rustix/tests/io/error.rs @@ -0,0 +1,14 @@ +#[test] +fn test_error() { + assert_eq!( + rustix::io::Errno::INVAL, + rustix::io::Errno::from_raw_os_error(rustix::io::Errno::INVAL.raw_os_error()) + ); + #[cfg(not(windows))] + assert_eq!(rustix::io::Errno::INVAL.raw_os_error(), libc::EINVAL); + #[cfg(windows)] + assert_eq!( + rustix::io::Errno::INVAL.raw_os_error(), + windows_sys::Win32::Networking::WinSock::WSAEINVAL + ); +} diff --git a/vendor/rustix/tests/io/eventfd.rs b/vendor/rustix/tests/io/eventfd.rs new file mode 100644 index 000000000..11bc8ae55 --- /dev/null +++ b/vendor/rustix/tests/io/eventfd.rs @@ -0,0 +1,24 @@ +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_eventfd() { + use rustix::io::{eventfd, read, write, EventfdFlags}; + use std::mem::size_of; + use std::thread; + + let efd = eventfd(0, EventfdFlags::CLOEXEC).unwrap(); + + let child = thread::spawn(move || { + for u in [1_u64, 3, 6, 11, 5000].iter() { + assert_eq!(write(&efd, &u.to_ne_bytes()).unwrap(), size_of::<u64>()); + } + efd + }); + + let efd = child.join().unwrap(); + + let mut bytes = [0_u8; size_of::<u64>()]; + let s = read(&efd, &mut bytes).unwrap(); + assert_eq!(s, bytes.len()); + let u = u64::from_ne_bytes(bytes); + assert_eq!(u, 5021); +} diff --git a/vendor/rustix/tests/io/from_into.rs b/vendor/rustix/tests/io/from_into.rs new file mode 100644 index 000000000..94d915993 --- /dev/null +++ b/vendor/rustix/tests/io/from_into.rs @@ -0,0 +1,28 @@ +#[cfg(feature = "fs")] +#[cfg(not(target_os = "redox"))] +#[test] +fn test_owned() { + use rustix::fd::AsFd; + #[cfg(unix)] + use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd}; + #[cfg(target_os = "wasi")] + use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd}; + + let file = rustix::fs::openat( + rustix::fs::cwd(), + "Cargo.toml", + rustix::fs::OFlags::RDONLY, + rustix::fs::Mode::empty(), + ) + .unwrap(); + + let raw = file.as_raw_fd(); + assert_eq!(raw, file.as_fd().as_raw_fd()); + + let inner = file.into_raw_fd(); + assert_eq!(raw, inner); + + let new = unsafe { rustix::io::OwnedFd::from_raw_fd(inner) }; + let mut buf = [0_u8; 4]; + let _ = rustix::io::read(&new, &mut buf).unwrap(); +} diff --git a/vendor/rustix/tests/io/ioctl.rs b/vendor/rustix/tests/io/ioctl.rs new file mode 100644 index 000000000..e260e4884 --- /dev/null +++ b/vendor/rustix/tests/io/ioctl.rs @@ -0,0 +1,14 @@ +// `is_read_write` is not yet implemented on Windows. And `ioctl_fionread` +// on Windows doesn't work on files. +#[cfg(not(windows))] +#[test] +fn test_ioctls() { + let file = std::fs::File::open("Cargo.toml").unwrap(); + + assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false)); + + assert_eq!( + rustix::io::ioctl_fionread(&file).unwrap(), + file.metadata().unwrap().len() + ); +} diff --git a/vendor/rustix/tests/io/main.rs b/vendor/rustix/tests/io/main.rs new file mode 100644 index 000000000..bdd044809 --- /dev/null +++ b/vendor/rustix/tests/io/main.rs @@ -0,0 +1,31 @@ +//! Tests for [`rustix::io`]. + +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] + +#[cfg(not(feature = "rustc-dep-of-std"))] +#[cfg(not(windows))] +#[cfg(not(target_os = "wasi"))] +mod dup2_to_replace_stdio; +#[cfg(not(feature = "rustc-dep-of-std"))] // TODO +#[cfg(not(windows))] +#[cfg(feature = "net")] +#[cfg(not(target_os = "wasi"))] +mod epoll; +mod error; +#[cfg(not(windows))] +#[cfg(not(target_os = "wasi"))] +mod eventfd; +#[cfg(not(windows))] +mod from_into; +#[cfg(not(target_os = "redox"))] +mod ioctl; +mod poll; +#[cfg(all(feature = "procfs", any(target_os = "android", target_os = "linux")))] +mod procfs; +#[cfg(not(windows))] +#[cfg(not(target_os = "redox"))] // redox doesn't have cwd/openat +#[cfg(not(target_os = "wasi"))] // wasi support for S_IRUSR etc. submitted to libc in #2264 +mod read_write; +#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "android"))] +mod seals; diff --git a/vendor/rustix/tests/io/poll.rs b/vendor/rustix/tests/io/poll.rs new file mode 100644 index 000000000..ff2da695b --- /dev/null +++ b/vendor/rustix/tests/io/poll.rs @@ -0,0 +1,63 @@ +use rustix::fd::{AsFd, AsRawFd, FromRawFd, IntoRawFd, OwnedFd}; +#[cfg(not(windows))] +use rustix::io::{poll, retry_on_intr}; +use rustix::io::{PollFd, PollFlags}; + +#[cfg(not(windows))] +#[test] +fn test_poll() { + use rustix::io::{pipe, read, write}; + + // Create a pipe. + let (reader, writer) = pipe().unwrap(); + let mut poll_fds = [PollFd::new(&reader, PollFlags::IN)]; + assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); + + // `poll` should say there's nothing ready to be read from the pipe. + let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap(); + assert_eq!(num, 0); + assert!(poll_fds[0].revents().is_empty()); + assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); + + // Write a byte to the pipe. + assert_eq!(retry_on_intr(|| write(&writer, b"a")).unwrap(), 1); + + // `poll` should now say there's data to be read. + let num = retry_on_intr(|| poll(&mut poll_fds, -1)).unwrap(); + assert_eq!(num, 1); + assert_eq!(poll_fds[0].revents(), PollFlags::IN); + assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); + + let mut temp = poll_fds[0].clone(); + assert_eq!(temp.revents(), PollFlags::IN); + temp.clear_revents(); + assert!(temp.revents().is_empty()); + + // Read the byte from the pipe. + let mut buf = [b'\0']; + assert_eq!(retry_on_intr(|| read(&reader, &mut buf)).unwrap(), 1); + assert_eq!(buf[0], b'a'); + assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); + + // Poll should now say there's no more data to be read. + let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap(); + assert_eq!(num, 0); + assert!(poll_fds[0].revents().is_empty()); + assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); +} + +#[test] +fn test_poll_fd_set_fd() { + // Make up some file descriptors so that we can test that set_fd works. + let a = unsafe { OwnedFd::from_raw_fd(777) }; + let mut poll_fd = PollFd::new(&a, PollFlags::empty()); + assert_eq!(poll_fd.as_fd().as_raw_fd(), 777); + + let b = unsafe { OwnedFd::from_raw_fd(888) }; + poll_fd.set_fd(&b); + assert_eq!(poll_fd.as_fd().as_raw_fd(), 888); + + // Don't attempt to close our made-up file descriptors. + let _ = a.into_raw_fd(); + let _ = b.into_raw_fd(); +} diff --git a/vendor/rustix/tests/io/procfs.rs b/vendor/rustix/tests/io/procfs.rs new file mode 100644 index 000000000..4c4256bd7 --- /dev/null +++ b/vendor/rustix/tests/io/procfs.rs @@ -0,0 +1,8 @@ +use io_lifetimes::raw::AsRawFilelike; + +#[test] +fn test_proc_self() { + // Verify that this API works at all + let fd = rustix::io::proc_self_fd().unwrap(); + assert_ne!(fd.as_raw_filelike(), 0); +} diff --git a/vendor/rustix/tests/io/read_write.rs b/vendor/rustix/tests/io/read_write.rs new file mode 100644 index 000000000..65186bf21 --- /dev/null +++ b/vendor/rustix/tests/io/read_write.rs @@ -0,0 +1,118 @@ +#[cfg(feature = "fs")] +use std::io::{IoSlice, IoSliceMut}; + +#[cfg(feature = "fs")] +#[test] +fn test_readwrite_pv() { + use rustix::fs::{cwd, openat, Mode, OFlags}; + use rustix::io::{preadv, pwritev}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let foo = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + // For most targets, just call `pwritev`. + #[cfg(not(any(target_os = "ios", target_os = "macos")))] + { + pwritev(&foo, &[IoSlice::new(b"hello")], 200).unwrap(); + } + // macOS only has pwritev in newer versions; allow it to fail with `ENOSYS`. + #[cfg(any(target_os = "ios", target_os = "macos"))] + { + match pwritev(&foo, &[IoSlice::new(b"hello")], 200) { + Ok(_) => (), + Err(rustix::io::Errno::NOSYS) => return, + Err(err) => Err(err).unwrap(), + } + } + pwritev(&foo, &[IoSlice::new(b"world")], 300).unwrap(); + let mut buf = [0_u8; 5]; + preadv(&foo, &mut [IoSliceMut::new(&mut buf)], 200).unwrap(); + assert_eq!(&buf, b"hello"); + preadv(&foo, &mut [IoSliceMut::new(&mut buf)], 300).unwrap(); + assert_eq!(&buf, b"world"); +} + +#[cfg(feature = "fs")] +#[test] +fn test_readwrite_p() { + use rustix::fs::{cwd, openat, Mode, OFlags}; + use rustix::io::{pread, pwrite}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let foo = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + pwrite(&foo, b"hello", 200).unwrap(); + pwrite(&foo, b"world", 300).unwrap(); + let mut buf = [0_u8; 5]; + pread(&foo, &mut buf, 200).unwrap(); + assert_eq!(&buf, b"hello"); + pread(&foo, &mut buf, 300).unwrap(); + assert_eq!(&buf, b"world"); +} + +#[cfg(feature = "fs")] +#[test] +fn test_readwrite_v() { + use rustix::fs::{cwd, openat, seek, Mode, OFlags}; + use rustix::io::{readv, writev, SeekFrom}; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let foo = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + writev(&foo, &[IoSlice::new(b"hello")]).unwrap(); + writev(&foo, &[IoSlice::new(b"world")]).unwrap(); + seek(&foo, SeekFrom::Start(0)).unwrap(); + let mut buf = [0_u8; 5]; + readv(&foo, &mut [IoSliceMut::new(&mut buf)]).unwrap(); + assert_eq!(&buf, b"hello"); + readv(&foo, &mut [IoSliceMut::new(&mut buf)]).unwrap(); + assert_eq!(&buf, b"world"); +} + +#[cfg(feature = "fs")] +#[test] +fn test_readwrite() { + use rustix::fs::{cwd, openat, seek, Mode, OFlags}; + use rustix::io::{read, write}; + use std::io::SeekFrom; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + let foo = openat( + &dir, + "foo", + OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, + Mode::RUSR | Mode::WUSR, + ) + .unwrap(); + + write(&foo, b"hello").unwrap(); + write(&foo, b"world").unwrap(); + seek(&foo, SeekFrom::Start(0)).unwrap(); + let mut buf = [0_u8; 5]; + read(&foo, &mut buf).unwrap(); + assert_eq!(&buf, b"hello"); + read(&foo, &mut buf).unwrap(); + assert_eq!(&buf, b"world"); +} diff --git a/vendor/rustix/tests/io/seals.rs b/vendor/rustix/tests/io/seals.rs new file mode 100644 index 000000000..ff971fa75 --- /dev/null +++ b/vendor/rustix/tests/io/seals.rs @@ -0,0 +1,41 @@ +#[cfg(feature = "fs")] +#[test] +fn test_seals() { + use rustix::fd::FromFd; + use rustix::fs::{ + fcntl_add_seals, fcntl_get_seals, ftruncate, memfd_create, MemfdFlags, SealFlags, + }; + use std::fs::File; + use std::io::Write; + + let fd = match memfd_create("test", MemfdFlags::CLOEXEC | MemfdFlags::ALLOW_SEALING) { + Ok(fd) => fd, + Err(rustix::io::Errno::NOSYS) => return, + Err(err) => Err(err).unwrap(), + }; + let mut file = File::from_fd(fd.into()); + + let old = fcntl_get_seals(&file).unwrap(); + assert_eq!(old, SealFlags::empty()); + + writeln!(&mut file, "Hello!").unwrap(); + + fcntl_add_seals(&file, SealFlags::GROW).unwrap(); + + let now = fcntl_get_seals(&file).unwrap(); + assert_eq!(now, SealFlags::GROW); + + // We sealed growing, so this should fail. + writeln!(&mut file, "World?").unwrap_err(); + + // We can still shrink for now. + ftruncate(&mut file, 1).unwrap(); + + fcntl_add_seals(&file, SealFlags::SHRINK).unwrap(); + + let now = fcntl_get_seals(&file).unwrap(); + assert_eq!(now, SealFlags::GROW | SealFlags::SHRINK); + + // We sealed shrinking, so this should fail. + ftruncate(&mut file, 0).unwrap_err(); +} diff --git a/vendor/rustix/tests/mm/main.rs b/vendor/rustix/tests/mm/main.rs new file mode 100644 index 000000000..ee746d900 --- /dev/null +++ b/vendor/rustix/tests/mm/main.rs @@ -0,0 +1,13 @@ +//! Tests for [`rustix::mm`]. + +#![cfg(feature = "mm")] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] + +#[cfg(not(windows))] +#[cfg(not(target_os = "wasi"))] +mod mlock; +#[cfg(not(windows))] +mod mmap; +#[cfg(not(windows))] +mod prot; diff --git a/vendor/rustix/tests/mm/mlock.rs b/vendor/rustix/tests/mm/mlock.rs new file mode 100644 index 000000000..c4a1a83b5 --- /dev/null +++ b/vendor/rustix/tests/mm/mlock.rs @@ -0,0 +1,79 @@ +//! Tests for `mlock`. +//! +//! We can't easily test that it actually locks memory, but we can test that we +//! can call it and either get success or a reasonable error message. + +use std::ffi::c_void; + +#[test] +fn test_mlock() { + let mut buf = vec![0_u8; 4096]; + + unsafe { + match rustix::mm::mlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()) { + Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), + // Tests won't always have enough memory or permissions, and that's ok. + Err(rustix::io::Errno::PERM) | Err(rustix::io::Errno::NOMEM) => {} + // But they shouldn't fail otherwise. + Err(other) => Err(other).unwrap(), + } + } +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_mlock_with() { + let mut buf = vec![0_u8; 4096]; + + unsafe { + match rustix::mm::mlock_with( + buf.as_mut_ptr().cast::<c_void>(), + buf.len(), + rustix::mm::MlockFlags::empty(), + ) { + Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), + // Tests won't always have enough memory or permissions, and that's ok. + Err(rustix::io::Errno::PERM) + | Err(rustix::io::Errno::NOMEM) + | Err(rustix::io::Errno::NOSYS) => {} + // But they shouldn't fail otherwise. + Err(other) => Err(other).unwrap(), + } + } +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_mlock_with_onfault() { + // With glibc, `mlock2` with `MLOCK_ONFAULT` returns `EINVAL` if the + // `mlock2` system call returns `ENOSYS`. That's not what we want + // here though, because `ENOSYS` just means the OS doesn't have + // `mlock2`, while `EINVAL` may indicate a bug in rustix. + // + // To work around this, we use `libc::syscall` to make a `mlock2` + // syscall directly to test for `ENOSYS`, before running the main + // test below. + unsafe { + if libc::syscall(libc::SYS_mlock2, 0, 0) == -1 && libc_errno::errno().0 == libc::ENOSYS { + return; + } + } + + let mut buf = vec![0_u8; 4096]; + + unsafe { + match rustix::mm::mlock_with( + buf.as_mut_ptr().cast::<c_void>(), + buf.len(), + rustix::mm::MlockFlags::ONFAULT, + ) { + Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), + // Tests won't always have enough memory or permissions, and that's ok. + Err(rustix::io::Errno::PERM) + | Err(rustix::io::Errno::NOMEM) + | Err(rustix::io::Errno::NOSYS) => {} + // But they shouldn't fail otherwise. + Err(other) => Err(other).unwrap(), + } + } +} diff --git a/vendor/rustix/tests/mm/mmap.rs b/vendor/rustix/tests/mm/mmap.rs new file mode 100644 index 000000000..6b27287d7 --- /dev/null +++ b/vendor/rustix/tests/mm/mmap.rs @@ -0,0 +1,163 @@ +#![cfg(not(target_os = "wasi"))] + +#[cfg(feature = "fs")] +#[cfg(not(target_os = "redox"))] +#[test] +fn test_mmap() { + use rustix::fs::{cwd, openat, Mode, OFlags}; + use rustix::io::write; + use rustix::mm::{mmap, munmap, MapFlags, ProtFlags}; + use std::ptr::null_mut; + use std::slice; + + let tmp = tempfile::tempdir().unwrap(); + let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); + + let file = openat( + &dir, + "foo", + OFlags::CREATE | OFlags::WRONLY | OFlags::TRUNC, + Mode::RUSR, + ) + .unwrap(); + write(&file, &[b'a'; 8192]).unwrap(); + drop(file); + + let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); + unsafe { + let addr = mmap( + null_mut(), + 8192, + ProtFlags::READ, + MapFlags::PRIVATE, + &file, + 0, + ) + .unwrap(); + let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); + assert_eq!(slice, &[b'a'; 8192]); + + munmap(addr, 8192).unwrap(); + } + + let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); + unsafe { + assert_eq!( + mmap( + null_mut(), + 8192, + ProtFlags::READ, + MapFlags::PRIVATE, + &file, + u64::MAX, + ) + .unwrap_err() + .raw_os_error(), + libc::EINVAL + ); + } +} + +#[test] +fn test_mmap_anonymous() { + use rustix::mm::{mmap_anonymous, munmap, MapFlags, ProtFlags}; + use std::ptr::null_mut; + use std::slice; + + unsafe { + let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); + let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); + assert_eq!(slice, &[b'\0'; 8192]); + + munmap(addr, 8192).unwrap(); + } +} + +#[test] +fn test_mprotect() { + use rustix::mm::{mmap_anonymous, mprotect, munmap, MapFlags, MprotectFlags, ProtFlags}; + use std::ptr::null_mut; + use std::slice; + + unsafe { + let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); + + mprotect(addr, 8192, MprotectFlags::empty()).unwrap(); + mprotect(addr, 8192, MprotectFlags::READ).unwrap(); + + let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); + assert_eq!(slice, &[b'\0'; 8192]); + + munmap(addr, 8192).unwrap(); + } +} + +#[test] +fn test_mlock() { + use rustix::mm::{mlock, mmap_anonymous, munlock, munmap, MapFlags, ProtFlags}; + #[cfg(any(target_os = "android", target_os = "linux"))] + use rustix::mm::{mlock_with, MlockFlags}; + use std::ptr::null_mut; + + unsafe { + let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); + + mlock(addr, 8192).unwrap(); + munlock(addr, 8192).unwrap(); + + #[cfg(any(target_os = "android", target_os = "linux"))] + { + match mlock_with(addr, 8192, MlockFlags::empty()) { + Err(rustix::io::Errno::NOSYS) => (), + Err(err) => Err(err).unwrap(), + Ok(()) => munlock(addr, 8192).unwrap(), + } + + #[cfg(linux_raw)] // libc doesn't expose `MLOCK_UNFAULT` yet. + { + match mlock_with(addr, 8192, MlockFlags::ONFAULT) { + Err(rustix::io::Errno::NOSYS) => (), + Err(err) => Err(err).unwrap(), + Ok(()) => munlock(addr, 8192).unwrap(), + } + munlock(addr, 8192).unwrap(); + } + } + + munmap(addr, 8192).unwrap(); + } +} + +#[cfg(not(target_os = "redox"))] +#[test] +fn test_madvise() { + use rustix::mm::{madvise, mmap_anonymous, munmap, Advice, MapFlags, ProtFlags}; + use std::ptr::null_mut; + + unsafe { + let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); + + madvise(addr, 8192, Advice::Normal).unwrap(); + madvise(addr, 8192, Advice::DontNeed).unwrap(); + + #[cfg(any(target_os = "android", target_os = "linux"))] + madvise(addr, 8192, Advice::LinuxDontNeed).unwrap(); + + munmap(addr, 8192).unwrap(); + } +} + +#[test] +fn test_msync() { + use rustix::mm::{mmap_anonymous, msync, munmap, MapFlags, MsyncFlags, ProtFlags}; + use std::ptr::null_mut; + + unsafe { + let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); + + msync(addr, 8192, MsyncFlags::SYNC).unwrap(); + msync(addr, 8192, MsyncFlags::ASYNC).unwrap(); + + munmap(addr, 8192).unwrap(); + } +} diff --git a/vendor/rustix/tests/mm/prot.rs b/vendor/rustix/tests/mm/prot.rs new file mode 100644 index 000000000..6c86a8f2a --- /dev/null +++ b/vendor/rustix/tests/mm/prot.rs @@ -0,0 +1,4 @@ +#[test] +fn test_prot_flags() { + assert_eq!(libc::PROT_NONE, 0); +} diff --git a/vendor/rustix/tests/net/addr.rs b/vendor/rustix/tests/net/addr.rs new file mode 100644 index 000000000..124413132 --- /dev/null +++ b/vendor/rustix/tests/net/addr.rs @@ -0,0 +1,92 @@ +#[test] +fn encode_decode() { + #[cfg(unix)] + use rustix::net::SocketAddrUnix; + use rustix::net::{ + Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrStorage, SocketAddrV4, SocketAddrV6, + }; + + unsafe { + let orig = SocketAddrV4::new(Ipv4Addr::new(2, 3, 5, 6), 33); + let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); + let len = SocketAddrAny::V4(orig).write(encoded.as_mut_ptr()); + let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); + assert_eq!(decoded, SocketAddrAny::V4(orig)); + + let orig = SocketAddrV6::new(Ipv6Addr::new(2, 3, 5, 6, 8, 9, 11, 12), 33, 34, 36); + let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); + let len = SocketAddrAny::V6(orig).write(encoded.as_mut_ptr()); + let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); + assert_eq!(decoded, SocketAddrAny::V6(orig)); + + #[cfg(not(windows))] + { + let orig = SocketAddrUnix::new("/path/to/socket").unwrap(); + let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); + let len = SocketAddrAny::Unix(orig.clone()).write(encoded.as_mut_ptr()); + let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); + assert_eq!(decoded, SocketAddrAny::Unix(orig)); + } + } +} + +#[cfg(not(windows))] +#[test] +fn test_unix_addr() { + use rustix::cstr; + use rustix::net::SocketAddrUnix; + + assert_eq!( + SocketAddrUnix::new("/").unwrap().path().unwrap(), + cstr!("/") + ); + assert_eq!( + SocketAddrUnix::new("//").unwrap().path().unwrap(), + cstr!("//") + ); + assert_eq!( + SocketAddrUnix::new("/foo/bar").unwrap().path().unwrap(), + cstr!("/foo/bar") + ); + assert_eq!( + SocketAddrUnix::new("foo").unwrap().path().unwrap(), + cstr!("foo") + ); + SocketAddrUnix::new("/foo\0/bar").unwrap_err(); + assert!(SocketAddrUnix::new("").unwrap().path().is_none()); + + #[cfg(any(target_os = "android", target_os = "linux"))] + { + assert!(SocketAddrUnix::new("foo") + .unwrap() + .abstract_name() + .is_none()); + + assert_eq!( + SocketAddrUnix::new_abstract_name(b"test") + .unwrap() + .abstract_name() + .unwrap(), + b"test" + ); + assert_eq!( + SocketAddrUnix::new_abstract_name(b"") + .unwrap() + .abstract_name() + .unwrap(), + b"" + ); + assert_eq!( + SocketAddrUnix::new_abstract_name(b"this\0that") + .unwrap() + .abstract_name() + .unwrap(), + b"this\0that" + ); + SocketAddrUnix::new_abstract_name(&[b'a'; 500]).unwrap_err(); + assert!(SocketAddrUnix::new_abstract_name(b"test") + .unwrap() + .path() + .is_none()); + } +} diff --git a/vendor/rustix/tests/net/connect_bind_send.rs b/vendor/rustix/tests/net/connect_bind_send.rs new file mode 100644 index 000000000..84720975f --- /dev/null +++ b/vendor/rustix/tests/net/connect_bind_send.rs @@ -0,0 +1,487 @@ +use rustix::net::{ + AddressFamily, Ipv6Addr, Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4, + SocketAddrV6, SocketType, +}; +use std::net::{IpAddr, Ipv4Addr, SocketAddr}; + +/// Test `connect_any`. +#[test] +fn net_v4_connect_any() -> std::io::Result<()> { + let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Similar, but with V6. +#[test] +fn net_v6_connect_any() -> std::io::Result<()> { + let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Test `connect` with a `SocketAddr`. +#[test] +fn net_v4_connect() -> std::io::Result<()> { + let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let local_addr = match local_addr { + SocketAddrAny::V4(v4) => SocketAddr::V4(v4), + other => panic!("unexpected socket address {:?}", other), + }; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Similar, but use V6. +#[test] +fn net_v6_connect() -> std::io::Result<()> { + let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let local_addr = match local_addr { + SocketAddrAny::V6(v6) => SocketAddr::V6(v6), + other => panic!("unexpected socket address {:?}", other), + }; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Test `bind_any`. +#[test] +fn net_v4_bind_any() -> std::io::Result<()> { + let localhost = Ipv4Addr::LOCALHOST; + let addr = SocketAddrAny::V4(SocketAddrV4::new(localhost, 0)); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind_any(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Similar, but use V6. +#[test] +fn net_v6_bind_any() -> std::io::Result<()> { + let localhost = Ipv6Addr::LOCALHOST; + let addr = SocketAddrAny::V6(SocketAddrV6::new(localhost, 0, 0, 0)); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind_any(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Test `sendto`. +#[test] +fn net_v4_sendto() -> std::io::Result<()> { + let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let local_addr = match local_addr { + SocketAddrAny::V4(v4) => SocketAddr::V4(v4), + other => panic!("unexpected socket address {:?}", other), + }; + let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let (n, from) = + rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + assert!(from.is_none()); + + Ok(()) +} + +/// Similar, but with V6. +#[test] +fn net_v6_sendto() -> std::io::Result<()> { + let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let local_addr = match local_addr { + SocketAddrAny::V6(v6) => SocketAddr::V6(v6), + other => panic!("unexpected socket address {:?}", other), + }; + let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let (n, from) = + rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + assert!(from.is_none()); + + Ok(()) +} + +/// Test `sendto_any`. +#[test] +fn net_v4_sendto_any() -> std::io::Result<()> { + let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = + rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let (n, from) = + rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + assert!(from.is_none()); + + Ok(()) +} + +/// Test `sendto_any`. +#[test] +fn net_v6_sendto_any() -> std::io::Result<()> { + let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = + rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let accepted = rustix::net::accept(&listener).expect("accept"); + let mut response = [0_u8; 128]; + let (n, from) = + rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + assert!(from.is_none()); + + Ok(()) +} + +/// Test `acceptfrom`. +#[test] +fn net_v4_acceptfrom() -> std::io::Result<()> { + let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept"); + + assert_ne!(from.clone().unwrap(), local_addr); + + let from = match from.unwrap() { + SocketAddrAny::V4(v4) => v4, + other => panic!("unexpected socket address {:?}", other), + }; + let local_addr = match local_addr { + SocketAddrAny::V4(v4) => v4, + other => panic!("unexpected socket address {:?}", other), + }; + + assert_eq!(from.clone().ip(), local_addr.ip()); + assert_ne!(from.clone().port(), local_addr.port()); + + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} + +/// Similar, but with V6. +#[test] +fn net_v6_acceptfrom() -> std::io::Result<()> { + let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); + let addr = SocketAddr::new(localhost, 0); + let listener = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::bind(&listener, &addr).expect("bind"); + rustix::net::listen(&listener, 1).expect("listen"); + + let local_addr = rustix::net::getsockname(&listener)?; + let sender = rustix::net::socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + )?; + rustix::net::connect_any(&sender, &local_addr).expect("connect"); + let request = b"Hello, World!!!"; + let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); + drop(sender); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept"); + + assert_ne!(from.clone().unwrap(), local_addr); + + let from = match from.unwrap() { + SocketAddrAny::V6(v6) => v6, + other => panic!("unexpected socket address {:?}", other), + }; + let local_addr = match local_addr { + SocketAddrAny::V6(v6) => v6, + other => panic!("unexpected socket address {:?}", other), + }; + + assert_eq!(from.clone().ip(), local_addr.ip()); + assert_ne!(from.clone().port(), local_addr.port()); + + let mut response = [0_u8; 128]; + let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); + + // Not strictly required, but it makes the test simpler. + assert_eq!(n, request.len()); + + assert_eq!(request, &response[..n]); + + Ok(()) +} diff --git a/vendor/rustix/tests/net/main.rs b/vendor/rustix/tests/net/main.rs new file mode 100644 index 000000000..0745282aa --- /dev/null +++ b/vendor/rustix/tests/net/main.rs @@ -0,0 +1,32 @@ +//! Tests for [`rustix::net`]. + +#![cfg(feature = "net")] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg_attr(core_c_str, feature(core_c_str))] + +mod addr; +mod connect_bind_send; +mod poll; +mod sockopt; +#[cfg(unix)] +mod unix; +mod v4; +mod v6; + +/// Windows requires us to call a setup function before using any of the +/// socket APIs. +#[cfg(windows)] +#[ctor::ctor] +fn windows_startup() { + let _ = rustix::net::wsa_startup().unwrap(); +} + +/// Windows requires us to call a cleanup function after using any of the +/// socket APIs. +#[cfg(windows)] +#[ctor::dtor] +fn windows_shutdown() { + rustix::net::wsa_cleanup().unwrap(); +} diff --git a/vendor/rustix/tests/net/poll.rs b/vendor/rustix/tests/net/poll.rs new file mode 100644 index 000000000..7933983f2 --- /dev/null +++ b/vendor/rustix/tests/net/poll.rs @@ -0,0 +1,119 @@ +//! The same as v6.rs, but with `poll` calls. + +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] + +use rustix::io::{poll, PollFd, PollFlags}; +use rustix::net::{ + accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr, + Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType, +}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; + +const BUFFER_SIZE: usize = 20; + +fn server(ready: Arc<(Mutex<u16>, Condvar)>) { + let connection_socket = socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + ) + .unwrap(); + + let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0); + bind_v6(&connection_socket, &name).unwrap(); + + let who = match getsockname(&connection_socket).unwrap() { + SocketAddrAny::V6(addr) => addr, + _ => panic!(), + }; + + listen(&connection_socket, 1).unwrap(); + + { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + *port = who.port(); + cvar.notify_all(); + } + + let mut buffer = vec![0; BUFFER_SIZE]; + let data_socket = accept(&connection_socket).unwrap(); + + let mut fds = [PollFd::new(&data_socket, PollFlags::IN)]; + assert_eq!(poll(&mut fds, -1).unwrap(), 1); + assert!(fds[0].revents().intersects(PollFlags::IN)); + assert!(!fds[0].revents().intersects(PollFlags::OUT)); + + let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap(); + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); + assert_eq!(expected_nread, nread as u64); + + let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)]; + assert_eq!(poll(&mut fds, -1).unwrap(), 1); + assert!(!fds[0].revents().intersects(PollFlags::IN)); + assert!(fds[0].revents().intersects(PollFlags::OUT)); + + send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); +} + +fn client(ready: Arc<(Mutex<u16>, Condvar)>) { + let port = { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + while *port == 0 { + port = cvar.wait(port).unwrap(); + } + *port + }; + + let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0); + let mut buffer = vec![0; BUFFER_SIZE]; + + let data_socket = socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + ) + .unwrap(); + connect_v6(&data_socket, &addr).unwrap(); + + let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)]; + assert_eq!(poll(&mut fds, -1).unwrap(), 1); + assert!(!fds[0].revents().intersects(PollFlags::IN)); + assert!(fds[0].revents().intersects(PollFlags::OUT)); + + send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); + + let mut fds = [PollFd::new(&data_socket, PollFlags::IN)]; + assert_eq!(poll(&mut fds, -1).unwrap(), 1); + assert!(fds[0].revents().intersects(PollFlags::IN)); + assert!(!fds[0].revents().intersects(PollFlags::OUT)); + + let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap(); + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); + assert_eq!(expected_nread, nread as u64); +} + +#[test] +fn test_poll() { + let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); + let ready_clone = Arc::clone(&ready); + + let server = thread::Builder::new() + .name("server".to_string()) + .spawn(move || { + server(ready); + }) + .unwrap(); + let client = thread::Builder::new() + .name("client".to_string()) + .spawn(move || { + client(ready_clone); + }) + .unwrap(); + client.join().unwrap(); + server.join().unwrap(); +} diff --git a/vendor/rustix/tests/net/sockopt.rs b/vendor/rustix/tests/net/sockopt.rs new file mode 100644 index 000000000..8e4cf52e8 --- /dev/null +++ b/vendor/rustix/tests/net/sockopt.rs @@ -0,0 +1,158 @@ +#[test] +fn test_sockopts() { + use rustix::net::{AddressFamily, Protocol, SocketType}; + use std::time::Duration; + + let s = + rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); + + // On a new socket we shouldn't have a timeout yet. + assert!( + rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) + .unwrap() + .is_none() + ); + assert_eq!( + rustix::net::sockopt::get_socket_type(&s).unwrap(), + SocketType::STREAM + ); + #[cfg(not(windows))] + assert_eq!( + rustix::net::sockopt::get_socket_broadcast(&s).unwrap(), + false + ); + // On a new socket we shouldn't have a linger yet. + assert!(rustix::net::sockopt::get_socket_linger(&s) + .unwrap() + .is_none()); + #[cfg(any(target_os = "android", target_os = "linux"))] + assert_eq!( + rustix::net::sockopt::get_socket_passcred(&s).unwrap(), + false + ); + assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 0); + assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77); + #[cfg(not(any( + windows, + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + )))] + assert_eq!( + rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(), + true + ); + #[cfg(not(any( + windows, + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + )))] + assert_eq!(rustix::net::sockopt::get_ip_multicast_ttl(&s).unwrap(), 1); + assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), false); + + // Set a timeout. + rustix::net::sockopt::set_socket_timeout( + &s, + rustix::net::sockopt::Timeout::Recv, + Some(Duration::new(1, 1)), + ) + .unwrap(); + + // Check that we have a timeout of at least the time we set. + if cfg!(not(target_os = "freebsd")) { + assert!( + rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) + .unwrap() + .unwrap() + >= Duration::new(1, 1) + ); + } else { + // On FreeBSD <= 12, it appears the system rounds the timeout down. + assert!( + rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) + .unwrap() + .unwrap() + >= Duration::new(1, 0) + ); + } + + #[cfg(not(windows))] + { + // Set the broadcast flag; + rustix::net::sockopt::set_socket_broadcast(&s, true).unwrap(); + + // Check that the broadcast flag is set. This has no effect on stream + // sockets, and not all platforms even remember the value. + #[cfg(not(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + )))] + assert_eq!( + rustix::net::sockopt::get_socket_broadcast(&s).unwrap(), + true + ); + } + + // Set a linger. + rustix::net::sockopt::set_socket_linger(&s, Some(Duration::new(1, 1))).unwrap(); + + // Check that we have a linger of at least the time we set. + assert!( + dbg!(rustix::net::sockopt::get_socket_linger(&s) + .unwrap() + .unwrap()) + >= Duration::new(1, 1) + ); + + #[cfg(any(target_os = "android", target_os = "linux"))] + { + // Set the passcred flag; + rustix::net::sockopt::set_socket_passcred(&s, true).unwrap(); + + // Check that the passcred flag is set. + assert_eq!(rustix::net::sockopt::get_socket_passcred(&s).unwrap(), true); + } + + // Set the ip ttl. + rustix::net::sockopt::set_ip_ttl(&s, 77).unwrap(); + + // Check the ip ttl. + assert_eq!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77); + + #[cfg(not(any( + windows, + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + )))] + { + // Set the multicast loop flag; + rustix::net::sockopt::set_ip_multicast_loop(&s, false).unwrap(); + + // Check that the multicast loop flag is set. + assert_eq!( + rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(), + false + ); + } + + // Set the nodelay flag; + rustix::net::sockopt::set_tcp_nodelay(&s, true).unwrap(); + + // Check that the nodelay flag is set. + assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), true); +} diff --git a/vendor/rustix/tests/net/unix.rs b/vendor/rustix/tests/net/unix.rs new file mode 100644 index 000000000..21a6542f8 --- /dev/null +++ b/vendor/rustix/tests/net/unix.rs @@ -0,0 +1,147 @@ +//! Test a simple Unix-domain socket server and client. +//! +//! The client sends lists of integers and the server sends back sums. + +// This test uses `AF_UNIX` with `SOCK_SEQPACKET` which is unsupported on macOS. +#![cfg(not(any( + target_os = "ios", + target_os = "macos", + target_os = "redox", + target_os = "wasi", +)))] +// This test uses `DecInt`. +#![cfg(feature = "itoa")] +#![cfg(feature = "fs")] + +use rustix::fs::{cwd, unlinkat, AtFlags}; +use rustix::io::{read, write}; +use rustix::net::{ + accept, bind_unix, connect_unix, listen, socket, AddressFamily, Protocol, SocketAddrUnix, + SocketType, +}; +use rustix::path::DecInt; +use std::path::Path; +use std::str::FromStr; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; + +const BUFFER_SIZE: usize = 20; + +fn server(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path) { + let connection_socket = socket( + AddressFamily::UNIX, + SocketType::SEQPACKET, + Protocol::default(), + ) + .unwrap(); + + let name = SocketAddrUnix::new(path).unwrap(); + bind_unix(&connection_socket, &name).unwrap(); + listen(&connection_socket, 1).unwrap(); + + { + let (lock, cvar) = &*ready; + let mut started = lock.lock().unwrap(); + *started = true; + cvar.notify_all(); + } + + let mut buffer = vec![0; BUFFER_SIZE]; + 'exit: loop { + let data_socket = accept(&connection_socket).unwrap(); + let mut sum = 0; + loop { + let nread = read(&data_socket, &mut buffer).unwrap(); + + if &buffer[..nread] == b"exit" { + break 'exit; + } + if &buffer[..nread] == b"sum" { + break; + } + + sum += i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap(); + } + + write(&data_socket, DecInt::new(sum).as_bytes()).unwrap(); + } + + unlinkat(cwd(), path, AtFlags::empty()).unwrap(); +} + +fn client(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path, runs: &[(&[&str], i32)]) { + { + let (lock, cvar) = &*ready; + let mut started = lock.lock().unwrap(); + while !*started { + started = cvar.wait(started).unwrap(); + } + } + + let addr = SocketAddrUnix::new(path).unwrap(); + let mut buffer = vec![0; BUFFER_SIZE]; + + for (args, sum) in runs { + let data_socket = socket( + AddressFamily::UNIX, + SocketType::SEQPACKET, + Protocol::default(), + ) + .unwrap(); + connect_unix(&data_socket, &addr).unwrap(); + + for arg in *args { + write(&data_socket, arg.as_bytes()).unwrap(); + } + write(&data_socket, b"sum").unwrap(); + + let nread = read(&data_socket, &mut buffer).unwrap(); + assert_eq!( + i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap(), + *sum + ); + } + + let data_socket = socket( + AddressFamily::UNIX, + SocketType::SEQPACKET, + Protocol::default(), + ) + .unwrap(); + connect_unix(&data_socket, &addr).unwrap(); + write(&data_socket, b"exit").unwrap(); +} + +#[test] +fn test_unix() { + let ready = Arc::new((Mutex::new(false), Condvar::new())); + let ready_clone = Arc::clone(&ready); + + let tmp = tempfile::tempdir().unwrap(); + let path = tmp.path().join("soccer"); + let send_path = path.to_owned(); + let server = thread::Builder::new() + .name("server".to_string()) + .spawn(move || { + server(ready, &send_path); + }) + .unwrap(); + let send_path = path.to_owned(); + let client = thread::Builder::new() + .name("client".to_string()) + .spawn(move || { + client( + ready_clone, + &send_path, + &[ + (&["1", "2"], 3), + (&["4", "77", "103"], 184), + (&["5", "78", "104"], 187), + (&[], 0), + ], + ); + }) + .unwrap(); + client.join().unwrap(); + server.join().unwrap(); +} diff --git a/vendor/rustix/tests/net/v4.rs b/vendor/rustix/tests/net/v4.rs new file mode 100644 index 000000000..0908057be --- /dev/null +++ b/vendor/rustix/tests/net/v4.rs @@ -0,0 +1,86 @@ +//! Test a simple IPv4 socket server and client. +//! +//! The client send a message and the server sends one back. + +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] + +use rustix::net::{ + accept, bind_v4, connect_v4, getsockname, listen, recv, send, socket, AddressFamily, Ipv4Addr, + Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4, SocketType, +}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; + +const BUFFER_SIZE: usize = 20; + +fn server(ready: Arc<(Mutex<u16>, Condvar)>) { + let connection_socket = + socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); + + let name = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 0); + bind_v4(&connection_socket, &name).unwrap(); + + let who = match getsockname(&connection_socket).unwrap() { + SocketAddrAny::V4(addr) => addr, + _ => panic!(), + }; + + listen(&connection_socket, 1).unwrap(); + + { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + *port = who.port(); + cvar.notify_all(); + } + + let mut buffer = vec![0; BUFFER_SIZE]; + let data_socket = accept(&connection_socket).unwrap(); + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); + + send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); +} + +fn client(ready: Arc<(Mutex<u16>, Condvar)>) { + let port = { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + while *port == 0 { + port = cvar.wait(port).unwrap(); + } + *port + }; + + let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), port); + let mut buffer = vec![0; BUFFER_SIZE]; + + let data_socket = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); + connect_v4(&data_socket, &addr).unwrap(); + + send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); + + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); +} + +#[test] +fn test_v4() { + let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); + let ready_clone = Arc::clone(&ready); + + let server = thread::Builder::new() + .name("server".to_string()) + .spawn(move || { + server(ready); + }) + .unwrap(); + let client = thread::Builder::new() + .name("client".to_string()) + .spawn(move || { + client(ready_clone); + }) + .unwrap(); + client.join().unwrap(); + server.join().unwrap(); +} diff --git a/vendor/rustix/tests/net/v6.rs b/vendor/rustix/tests/net/v6.rs new file mode 100644 index 000000000..07205be89 --- /dev/null +++ b/vendor/rustix/tests/net/v6.rs @@ -0,0 +1,95 @@ +//! Test a simple IPv6 socket server and client. +//! +//! The client send a message and the server sends one back. + +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] + +use rustix::net::{ + accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr, + Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType, +}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; + +const BUFFER_SIZE: usize = 20; + +fn server(ready: Arc<(Mutex<u16>, Condvar)>) { + let connection_socket = socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + ) + .unwrap(); + + let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0); + bind_v6(&connection_socket, &name).unwrap(); + + let who = match getsockname(&connection_socket).unwrap() { + SocketAddrAny::V6(addr) => addr, + _ => panic!(), + }; + + listen(&connection_socket, 1).unwrap(); + + { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + *port = who.port(); + cvar.notify_all(); + } + + let mut buffer = vec![0; BUFFER_SIZE]; + let data_socket = accept(&connection_socket).unwrap(); + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); + + send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); +} + +fn client(ready: Arc<(Mutex<u16>, Condvar)>) { + let port = { + let (lock, cvar) = &*ready; + let mut port = lock.lock().unwrap(); + while *port == 0 { + port = cvar.wait(port).unwrap(); + } + *port + }; + + let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0); + let mut buffer = vec![0; BUFFER_SIZE]; + + let data_socket = socket( + AddressFamily::INET6, + SocketType::STREAM, + Protocol::default(), + ) + .unwrap(); + connect_v6(&data_socket, &addr).unwrap(); + + send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); + + let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); + assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); +} + +#[test] +fn test_v6() { + let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); + let ready_clone = Arc::clone(&ready); + + let server = thread::Builder::new() + .name("server".to_string()) + .spawn(move || { + server(ready); + }) + .unwrap(); + let client = thread::Builder::new() + .name("client".to_string()) + .spawn(move || { + client(ready_clone); + }) + .unwrap(); + client.join().unwrap(); + server.join().unwrap(); +} diff --git a/vendor/rustix/tests/param/auxv.rs b/vendor/rustix/tests/param/auxv.rs new file mode 100644 index 000000000..90a088101 --- /dev/null +++ b/vendor/rustix/tests/param/auxv.rs @@ -0,0 +1,41 @@ +#[cfg(any( + all(target_os = "android", target_pointer_width = "64"), + target_os = "linux", +))] +use rustix::param::linux_hwcap; +use rustix::param::{clock_ticks_per_second, page_size}; + +#[test] +fn test_page_size() { + let size = page_size(); + assert_ne!(size, 0); + assert!(size.is_power_of_two()); + assert_eq!(size, page_size()); + assert_eq!(size, unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }); +} + +#[test] +fn test_clock_ticks_per_second() { + let size = clock_ticks_per_second(); + assert_ne!(size, 0); + assert_eq!(size, unsafe { libc::sysconf(libc::_SC_CLK_TCK) as u64 }); +} + +#[cfg(any( + all(target_os = "android", target_pointer_width = "64"), + target_os = "linux", +))] +#[test] +fn test_linux_hwcap() { + weak!(fn getauxval(libc::c_ulong) -> libc::c_ulong); + + if let Some(libc_getauxval) = getauxval.get() { + let (_hwcap, hwcap2) = linux_hwcap(); + + // GLIBC seems to return a different value than `LD_SHOW_AUXV=1` reports. + #[cfg(not(target_env = "gnu"))] + assert_eq!(_hwcap, unsafe { libc_getauxval(libc::AT_HWCAP) } as usize); + + assert_eq!(hwcap2, unsafe { libc_getauxval(libc::AT_HWCAP2) } as usize); + } +} diff --git a/vendor/rustix/tests/param/main.rs b/vendor/rustix/tests/param/main.rs new file mode 100644 index 000000000..e350a6f1f --- /dev/null +++ b/vendor/rustix/tests/param/main.rs @@ -0,0 +1,14 @@ +//! Tests for [`rustix::param`]. + +#![cfg(feature = "param")] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg_attr(core_c_str, feature(core_c_str))] + +#[cfg(not(target_os = "wasi"))] +#[macro_use] +mod weak; + +#[cfg(not(target_os = "wasi"))] +mod auxv; diff --git a/vendor/rustix/tests/param/weak.rs b/vendor/rustix/tests/param/weak.rs new file mode 100644 index 000000000..377a8a5a1 --- /dev/null +++ b/vendor/rustix/tests/param/weak.rs @@ -0,0 +1,201 @@ +// Implementation derived from `weak` in Rust's +// library/std/src/sys/unix/weak.rs at revision +// fd0cb0cdc21dd9c06025277d772108f8d42cb25f. + +//! Support for "weak linkage" to symbols on Unix +//! +//! Some I/O operations we do in libstd require newer versions of OSes but we +//! need to maintain binary compatibility with older releases for now. In order +//! to use the new functionality when available we use this module for +//! detection. +//! +//! One option to use here is weak linkage, but that is unfortunately only +//! really workable on Linux. Hence, use dlsym to get the symbol value at +//! runtime. This is also done for compatibility with older versions of glibc, +//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes +//! that we've been dynamically linked to the library the symbol comes from, +//! but that is currently always the case for things like libpthread/libc. +//! +//! A long time ago this used weak linkage for the `__pthread_get_minstack` +//! symbol, but that caused Debian to detect an unnecessarily strict versioned +//! dependency on libc6 (#23628). + +// There are a variety of `#[cfg]`s controlling which targets are involved in +// each instance of `weak!` and `syscall!`. Rather than trying to unify all of +// that, we'll just allow that some unix targets don't use this module at all. +#![allow(dead_code, unused_macros)] +#![allow(clippy::doc_markdown)] + +use core::ffi::c_void; +use core::ptr::null_mut; +use core::sync::atomic::{self, AtomicPtr, Ordering}; +use core::{marker, mem}; +use rustix::ffi::CStr; + +const NULL: *mut c_void = null_mut(); +const INVALID: *mut c_void = 1 as *mut c_void; + +macro_rules! weak { + (fn $name:ident($($t:ty),*) -> $ret:ty) => ( + #[allow(non_upper_case_globals)] + static $name: $crate::weak::Weak<unsafe extern fn($($t),*) -> $ret> = + $crate::weak::Weak::new(concat!(stringify!($name), '\0')); + ) +} + +pub(crate) struct Weak<F> { + name: &'static str, + addr: AtomicPtr<c_void>, + _marker: marker::PhantomData<F>, +} + +impl<F> Weak<F> { + pub(crate) const fn new(name: &'static str) -> Self { + Self { + name, + addr: AtomicPtr::new(INVALID), + _marker: marker::PhantomData, + } + } + + pub(crate) fn get(&self) -> Option<F> { + assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); + unsafe { + // Relaxed is fine here because we fence before reading through the + // pointer (see the comment below). + match self.addr.load(Ordering::Relaxed) { + INVALID => self.initialize(), + NULL => None, + addr => { + let func = mem::transmute_copy::<*mut c_void, F>(&addr); + // The caller is presumably going to read through this value + // (by calling the function we've dlsymed). This means we'd + // need to have loaded it with at least C11's consume + // ordering in order to be guaranteed that the data we read + // from the pointer isn't from before the pointer was + // stored. Rust has no equivalent to memory_order_consume, + // so we use an acquire fence (sorry, ARM). + // + // Now, in practice this likely isn't needed even on CPUs + // where relaxed and consume mean different things. The + // symbols we're loading are probably present (or not) at + // init, and even if they aren't the runtime dynamic loader + // is extremely likely have sufficient barriers internally + // (possibly implicitly, for example the ones provided by + // invoking `mprotect`). + // + // That said, none of that's *guaranteed*, and so we fence. + atomic::fence(Ordering::Acquire); + Some(func) + } + } + } + } + + // Cold because it should only happen during first-time initialization. + #[cold] + unsafe fn initialize(&self) -> Option<F> { + let val = fetch(self.name); + // This synchronizes with the acquire fence in `get`. + self.addr.store(val, Ordering::Release); + + match val { + NULL => None, + addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)), + } + } +} + +unsafe fn fetch(name: &str) -> *mut c_void { + let name = match CStr::from_bytes_with_nul(name.as_bytes()) { + Ok(c_str) => c_str, + Err(..) => return null_mut(), + }; + libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) +} + +#[cfg(not(any(target_os = "android", target_os = "linux")))] +macro_rules! syscall { + (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + unsafe fn $name($($arg_name: $t),*) -> $ret { + weak! { fn $name($($t),*) -> $ret } + + if let Some(fun) = $name.get() { + fun($($arg_name),*) + } else { + errno::set_errno(errno::Errno(libc::ENOSYS)); + -1 + } + } + ) +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +macro_rules! syscall { + (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + unsafe fn $name($($arg_name:$t),*) -> $ret { + // This looks like a hack, but concat_idents only accepts idents + // (not paths). + use libc::*; + + trait AsSyscallArg { + type SyscallArgType; + fn as_syscall_arg(self) -> Self::SyscallArgType; + } + + // Pass pointer types as pointers, to preserve provenance. + impl<T> AsSyscallArg for *mut T { + type SyscallArgType = *mut T; + fn as_syscall_arg(self) -> Self::SyscallArgType { self } + } + impl<T> AsSyscallArg for *const T { + type SyscallArgType = *const T; + fn as_syscall_arg(self) -> Self::SyscallArgType { self } + } + + // Pass `BorrowedFd` values as the integer value. + impl AsSyscallArg for $crate::fd::BorrowedFd<'_> { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { + $crate::fd::AsRawFd::as_raw_fd(&self) as _ + } + } + + // Coerce integer values into `c_long`. + impl AsSyscallArg for i32 { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + impl AsSyscallArg for u32 { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + impl AsSyscallArg for usize { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + + syscall( + concat_idents!(SYS_, $name), + $($arg_name.as_syscall_arg()),* + ) as $ret + } + ) +} + +macro_rules! weakcall { + ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + $vis unsafe fn $name($($arg_name: $t),*) -> $ret { + weak! { fn $name($($t),*) -> $ret } + + // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` + // interposition, but if it's not found just fail. + if let Some(fun) = $name.get() { + fun($($arg_name),*) + } else { + errno::set_errno(errno::Errno(libc::ENOSYS)); + -1 + } + } + ) +} diff --git a/vendor/rustix/tests/path/arg.rs b/vendor/rustix/tests/path/arg.rs new file mode 100644 index 000000000..0eb511be1 --- /dev/null +++ b/vendor/rustix/tests/path/arg.rs @@ -0,0 +1,167 @@ +use rustix::ffi::{CStr, CString}; +use rustix::io; +use rustix::path::Arg; +#[cfg(feature = "itoa")] +use rustix::path::DecInt; +use std::borrow::Cow; +use std::ffi::{OsStr, OsString}; +use std::path::{Component, Components, Iter, Path, PathBuf}; + +#[test] +fn test_arg() { + use rustix::cstr; + use std::borrow::Borrow; + + let t: &str = "hello"; + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: String = "hello".to_owned(); + assert_eq!("hello", Arg::as_str(&t).unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: &OsStr = OsStr::new("hello"); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: OsString = OsString::from("hello".to_owned()); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: &Path = Path::new("hello"); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: PathBuf = PathBuf::from("hello".to_owned()); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: &CStr = cstr!("hello"); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: CString = cstr!("hello").to_owned(); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!( + cstr!("hello"), + Borrow::borrow(&Arg::as_cow_c_str(&t).unwrap()) + ); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Components = Path::new("hello").components(); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Component = Path::new("hello").components().next().unwrap(); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Iter = Path::new("hello").iter(); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, str> = Cow::Borrowed("hello"); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, str> = Cow::Owned("hello".to_owned()); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, OsStr> = Cow::Borrowed(OsStr::new("hello")); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, OsStr> = Cow::Owned(OsString::from("hello".to_owned())); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, CStr> = Cow::Borrowed(cstr!("hello")); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Cow<'_, CStr> = Cow::Owned(cstr!("hello").to_owned()); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: &[u8] = b"hello"; + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + let t: Vec<u8> = b"hello".to_vec(); + assert_eq!("hello", t.as_str().unwrap()); + assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); + + #[cfg(feature = "itoa")] + { + let t: DecInt = DecInt::new(43110); + assert_eq!("43110", t.as_str()); + assert_eq!("43110".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(cstr!("43110"), Borrow::borrow(&t.as_cow_c_str().unwrap())); + assert_eq!(cstr!("43110"), t.as_c_str()); + assert_eq!(cstr!("43110"), Borrow::borrow(&t.into_c_str().unwrap())); + } +} + +#[test] +fn test_invalid() { + use std::borrow::Borrow; + + let t: &[u8] = b"hello\xc0world"; + assert_eq!(t.as_str().unwrap_err(), io::Errno::INVAL); + assert_eq!("hello\u{fffd}world".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!( + b"hello\xc0world\0", + Borrow::<CStr>::borrow(&t.as_cow_c_str().unwrap()).to_bytes_with_nul() + ); + assert_eq!( + b"hello\xc0world\0", + Borrow::<CStr>::borrow(&t.into_c_str().unwrap()).to_bytes_with_nul() + ); +} + +#[test] +fn test_embedded_nul() { + let t: &[u8] = b"hello\0world"; + assert_eq!("hello\0world", t.as_str().unwrap()); + assert_eq!("hello\0world".to_owned(), Arg::to_string_lossy(&t)); + assert_eq!(t.as_cow_c_str().unwrap_err(), io::Errno::INVAL); + assert_eq!(t.into_c_str().unwrap_err(), io::Errno::INVAL); +} diff --git a/vendor/rustix/tests/path/dec_int.rs b/vendor/rustix/tests/path/dec_int.rs new file mode 100644 index 000000000..6ce1a5123 --- /dev/null +++ b/vendor/rustix/tests/path/dec_int.rs @@ -0,0 +1,20 @@ +use rustix::path::DecInt; + +#[test] +fn test_dec_int() { + assert_eq!(DecInt::new(0).as_ref().to_str().unwrap(), "0"); + assert_eq!(DecInt::new(-1).as_ref().to_str().unwrap(), "-1"); + assert_eq!(DecInt::new(789).as_ref().to_str().unwrap(), "789"); + assert_eq!( + DecInt::new(i64::MIN).as_ref().to_str().unwrap(), + i64::MIN.to_string() + ); + assert_eq!( + DecInt::new(i64::MAX).as_ref().to_str().unwrap(), + i64::MAX.to_string() + ); + assert_eq!( + DecInt::new(u64::MAX).as_ref().to_str().unwrap(), + u64::MAX.to_string() + ); +} diff --git a/vendor/rustix/tests/path/main.rs b/vendor/rustix/tests/path/main.rs new file mode 100644 index 000000000..3215c7e5e --- /dev/null +++ b/vendor/rustix/tests/path/main.rs @@ -0,0 +1,13 @@ +//! Tests for [`rustix::path`]. + +#![cfg(any(feature = "fs", feature = "net"))] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg_attr(core_c_str, feature(core_c_str))] +#![cfg_attr(alloc_c_string, feature(alloc_c_string))] + +#[cfg(not(feature = "rustc-dep-of-std"))] +mod arg; +#[cfg(feature = "itoa")] +mod dec_int; diff --git a/vendor/rustix/tests/process/cpu_set.rs b/vendor/rustix/tests/process/cpu_set.rs new file mode 100644 index 000000000..c4d9edf08 --- /dev/null +++ b/vendor/rustix/tests/process/cpu_set.rs @@ -0,0 +1,14 @@ +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_cpu_set() { + let set = rustix::process::sched_getaffinity(None).unwrap(); + + let mut count = 0; + for i in 0..rustix::process::CpuSet::MAX_CPU { + if set.is_set(i) { + count += 1; + } + } + + assert_eq!(count, set.count()); +} diff --git a/vendor/rustix/tests/process/id.rs b/vendor/rustix/tests/process/id.rs new file mode 100644 index 000000000..10095fa60 --- /dev/null +++ b/vendor/rustix/tests/process/id.rs @@ -0,0 +1,65 @@ +use rustix::process; + +#[test] +fn test_getuid() { + assert_eq!(process::getuid(), process::getuid()); + unsafe { + assert_eq!(process::getuid().as_raw(), libc::getuid()); + assert_eq!(process::getuid().is_root(), libc::getuid() == 0); + } +} + +#[test] +fn test_getgid() { + assert_eq!(process::getgid(), process::getgid()); + unsafe { + assert_eq!(process::getgid().as_raw(), libc::getgid()); + assert_eq!(process::getgid().is_root(), libc::getgid() == 0); + } +} + +#[test] +fn test_geteuid() { + assert_eq!(process::geteuid(), process::geteuid()); + unsafe { + assert_eq!(process::geteuid().as_raw(), libc::geteuid()); + assert_eq!(process::geteuid().is_root(), libc::geteuid() == 0); + } +} + +#[test] +fn test_getegid() { + assert_eq!(process::getegid(), process::getegid()); + unsafe { + assert_eq!(process::getegid().as_raw(), libc::getegid()); + assert_eq!(process::getegid().is_root(), libc::getegid() == 0); + } +} + +#[test] +fn test_getpid() { + assert_eq!(process::getpid(), process::getpid()); + unsafe { + assert_eq!( + process::getpid().as_raw_nonzero().get() as libc::pid_t, + libc::getpid() + ); + assert_eq!(process::getpid().is_init(), libc::getpid() == 1); + } +} + +#[test] +fn test_getppid() { + assert_eq!(process::getppid(), process::getppid()); + unsafe { + assert_eq!( + process::Pid::as_raw(process::getppid()) as libc::pid_t, + libc::getppid() + ); + if let Some(ppid) = process::getppid() { + assert_eq!(ppid.is_init(), libc::getppid() == 1); + } else { + assert_eq!(libc::getppid(), 0); + } + } +} diff --git a/vendor/rustix/tests/process/main.rs b/vendor/rustix/tests/process/main.rs new file mode 100644 index 000000000..90aa34c59 --- /dev/null +++ b/vendor/rustix/tests/process/main.rs @@ -0,0 +1,28 @@ +//! Tests for [`rustix::process`]. + +#![cfg(feature = "process")] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg_attr(core_c_str, feature(core_c_str))] + +#[cfg(not(target_os = "wasi"))] +#[macro_use] +mod weak; + +mod cpu_set; +#[cfg(not(target_os = "wasi"))] // WASI doesn't have get[gpu]id. +mod id; +#[cfg(any(target_os = "android", target_os = "linux"))] +mod membarrier; +#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] // WASI doesn't have [gs]etpriority. +mod priority; +#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] +mod rlimit; +mod sched_yield; +#[cfg(not(target_os = "wasi"))] // WASI doesn't have uname. +mod uname; +#[cfg(not(target_os = "wasi"))] // WASI doesn't have waitpid. +mod wait; +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +mod working_directory; diff --git a/vendor/rustix/tests/process/membarrier.rs b/vendor/rustix/tests/process/membarrier.rs new file mode 100644 index 000000000..ed9b00c1a --- /dev/null +++ b/vendor/rustix/tests/process/membarrier.rs @@ -0,0 +1,40 @@ +#[test] +fn test_membarrier() { + use rustix::process::{membarrier, membarrier_query, MembarrierCommand, MembarrierQuery}; + + let query: MembarrierQuery = membarrier_query(); + + // Supported registration commands should succeed. + for cmd in [ + MembarrierCommand::RegisterGlobalExpedited, + MembarrierCommand::RegisterPrivateExpedited, + MembarrierCommand::RegisterPrivateExpeditedSyncCore, + MembarrierCommand::RegisterPrivateExpeditedRseq, + ] + .iter() + .copied() + { + if query.contains_command(cmd) { + membarrier(cmd).unwrap(); + } + } + + // All supported commands should now succeed, and all unsupported + // commands should fail. + for cmd in [ + MembarrierCommand::Global, + MembarrierCommand::GlobalExpedited, + MembarrierCommand::PrivateExpedited, + MembarrierCommand::PrivateExpeditedSyncCore, + MembarrierCommand::PrivateExpeditedRseq, + ] + .iter() + .copied() + { + if query.contains_command(cmd) { + membarrier(cmd).unwrap(); + } else { + membarrier(cmd).unwrap_err(); + } + } +} diff --git a/vendor/rustix/tests/process/priority.rs b/vendor/rustix/tests/process/priority.rs new file mode 100644 index 000000000..7feb1467a --- /dev/null +++ b/vendor/rustix/tests/process/priority.rs @@ -0,0 +1,83 @@ +use rustix::process::nice; +#[cfg(not(target_os = "redox"))] +use rustix::process::{getpriority_process, setpriority_process}; + +#[cfg(not(target_os = "freebsd"))] // FreeBSD's nice(3) doesn't return the old value. +#[test] +fn test_priorities() { + let old = nice(0).unwrap(); + + #[cfg(not(target_os = "redox"))] + { + let get_prio = getpriority_process(None).unwrap(); + assert_eq!(get_prio, old); + } + + // Lower the priority by one. + let new = nice(1).unwrap(); + + // If the test wasn't running with the lowest priority initially, test that + // we were able to lower the priority. + if old < 19 { + assert_eq!(old + 1, new); + } + + let get = nice(0).unwrap(); + assert_eq!(new, get); + + #[cfg(not(target_os = "redox"))] + { + let get_prio = getpriority_process(None).unwrap(); + assert_eq!(get_prio, new); + + setpriority_process(None, get + 1).unwrap(); + let now = getpriority_process(None).unwrap(); + + // If the test wasn't running with the lowest priority initially, test + // that we were able to lower the priority. + if get < 19 { + assert_eq!(get + 1, now); + } + setpriority_process(None, get + 10000).unwrap(); + let now = getpriority_process(None).unwrap(); + // Linux's max is 19; Darwin's max is 20. + assert!(now >= 19 && now <= 20); + // Darwin appears to return `EPERM` on an out of range `nice`. + if let Ok(again) = nice(1) { + assert_eq!(now, again); + } + } +} + +/// FreeBSD's `nice` doesn't return the new nice value, so use a specialized +/// test. +#[cfg(target_os = "freebsd")] +#[test] +fn test_priorities() { + let start = getpriority_process(None).unwrap(); + + let _ = nice(0).unwrap(); + + let now = getpriority_process(None).unwrap(); + assert_eq!(start, now); + + let _ = nice(1).unwrap(); + + let now = getpriority_process(None).unwrap(); + assert_eq!(start + 1, now); + + setpriority_process(None, start + 2).unwrap(); + + let now = getpriority_process(None).unwrap(); + assert_eq!(start + 2, now); + + setpriority_process(None, 10000).unwrap(); + + let now = getpriority_process(None).unwrap(); + assert_eq!(now, 20); + + let _ = nice(1).unwrap(); + + let now = getpriority_process(None).unwrap(); + assert_eq!(now, 20); +} diff --git a/vendor/rustix/tests/process/proc.rs b/vendor/rustix/tests/process/proc.rs new file mode 100644 index 000000000..e85d85883 --- /dev/null +++ b/vendor/rustix/tests/process/proc.rs @@ -0,0 +1,5 @@ +#[test] +fn test_proc_funcs() { + let _maps = rustix::io::proc_self_maps().unwrap(); + let _pagemap = rustix::io::proc_self_pagemap().unwrap(); +} diff --git a/vendor/rustix/tests/process/rlimit.rs b/vendor/rustix/tests/process/rlimit.rs new file mode 100644 index 000000000..b01f9204c --- /dev/null +++ b/vendor/rustix/tests/process/rlimit.rs @@ -0,0 +1,51 @@ +use rustix::process::{Resource, Rlimit}; + +#[test] +fn test_getrlimit() { + let lim = rustix::process::getrlimit(Resource::Stack); + assert_ne!(lim.current, Some(0)); + assert_ne!(lim.maximum, Some(0)); +} + +#[test] +fn test_setrlimit() { + let old = rustix::process::getrlimit(Resource::Core); + let new = Rlimit { + current: Some(0), + maximum: Some(4096), + }; + assert_ne!(old, new); + rustix::process::setrlimit(Resource::Core, new.clone()).unwrap(); + + let lim = rustix::process::getrlimit(Resource::Core); + assert_eq!(lim, new); + + #[cfg(any(target_os = "android", target_os = "linux"))] + { + let new = Rlimit { + current: Some(0), + maximum: Some(0), + }; + + let first = rustix::process::getrlimit(Resource::Core); + + let old = match rustix::process::prlimit(None, Resource::Core, new.clone()) { + Ok(rlimit) => rlimit, + Err(rustix::io::Errno::NOSYS) => return, + Err(e) => Err(e).unwrap(), + }; + + assert_eq!(first, old); + + let other = Rlimit { + current: Some(0), + maximum: Some(0), + }; + + let again = + rustix::process::prlimit(Some(rustix::process::getpid()), Resource::Core, other) + .unwrap(); + + assert_eq!(again, new); + } +} diff --git a/vendor/rustix/tests/process/sched_yield.rs b/vendor/rustix/tests/process/sched_yield.rs new file mode 100644 index 000000000..eacf17d5e --- /dev/null +++ b/vendor/rustix/tests/process/sched_yield.rs @@ -0,0 +1,7 @@ +use rustix::process::sched_yield; + +#[test] +fn test_sched_yield() { + // Just make sure we can call it. + sched_yield(); +} diff --git a/vendor/rustix/tests/process/uname.rs b/vendor/rustix/tests/process/uname.rs new file mode 100644 index 000000000..bc944c49e --- /dev/null +++ b/vendor/rustix/tests/process/uname.rs @@ -0,0 +1,13 @@ +#[test] +fn test_uname() { + let name: rustix::process::Uname = rustix::process::uname(); + + assert!(!name.sysname().to_bytes().is_empty()); + assert!(!name.nodename().to_bytes().is_empty()); + assert!(!name.release().to_bytes().is_empty()); + assert!(!name.version().to_bytes().is_empty()); + assert!(!name.machine().to_bytes().is_empty()); + + #[cfg(any(target_os = "android", target_os = "linux"))] + assert!(!name.domainname().to_bytes().is_empty()); +} diff --git a/vendor/rustix/tests/process/wait.rs b/vendor/rustix/tests/process/wait.rs new file mode 100644 index 000000000..a1f25a631 --- /dev/null +++ b/vendor/rustix/tests/process/wait.rs @@ -0,0 +1,25 @@ +use libc::{kill, SIGSTOP}; +use rustix::process; +use serial_test::serial; +use std::process::{Command, Stdio}; + +// These tests must execute serially to prevent race condition, where +// `test_wait` waits for the child process spawned in `test_waitpid`, causing +// the tests to get stuck. + +#[test] +#[serial] +fn test_waitpid() { + let child = Command::new("yes") + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn() + .expect("failed to execute child"); + unsafe { kill(child.id() as _, SIGSTOP) }; + + let pid = unsafe { process::Pid::from_raw(child.id() as _) }; + let status = process::waitpid(pid, process::WaitOptions::UNTRACED) + .expect("failed to wait") + .unwrap(); + assert!(status.stopped()); +} diff --git a/vendor/rustix/tests/process/weak.rs b/vendor/rustix/tests/process/weak.rs new file mode 100644 index 000000000..d4f00f999 --- /dev/null +++ b/vendor/rustix/tests/process/weak.rs @@ -0,0 +1,201 @@ +// Implementation derived from `weak` in Rust's +// library/std/src/sys/unix/weak.rs at revision +// fd0cb0cdc21dd9c06025277d772108f8d42cb25f. + +//! Support for "weak linkage" to symbols on Unix +//! +//! Some I/O operations we do in libstd require newer versions of OSes but we +//! need to maintain binary compatibility with older releases for now. In order +//! to use the new functionality when available we use this module for +//! detection. +//! +//! One option to use here is weak linkage, but that is unfortunately only +//! really workable on Linux. Hence, use dlsym to get the symbol value at +//! runtime. This is also done for compatibility with older versions of glibc, +//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes +//! that we've been dynamically linked to the library the symbol comes from, +//! but that is currently always the case for things like libpthread/libc. +//! +//! A long time ago this used weak linkage for the `__pthread_get_minstack` +//! symbol, but that caused Debian to detect an unnecessarily strict versioned +//! dependency on libc6 (#23628). + +// There are a variety of `#[cfg]`s controlling which targets are involved in +// each instance of `weak!` and `syscall!`. Rather than trying to unify all of +// that, we'll just allow that some unix targets don't use this module at all. +#![allow(dead_code, unused_macros)] +#![allow(clippy::doc_markdown)] + +use core::ffi::c_void; +use core::ptr::null_mut; +use core::sync::atomic::{self, AtomicPtr, Ordering}; +use core::{marker, mem}; +use rustix::ffi::CStr; + +const NULL: *mut c_void = null_mut(); +const INVALID: *mut c_void = 1 as *mut c_void; + +macro_rules! weak { + (fn $name:ident($($t:ty),*) -> $ret:ty) => ( + #[allow(non_upper_case_globals)] + static $name: $crate::weak::Weak<unsafe extern fn($($t),*) -> $ret> = + $crate::weak::Weak::new(concat!(stringify!($name), '\0')); + ) +} + +pub(crate) struct Weak<F> { + name: &'static str, + addr: AtomicPtr<c_void>, + _marker: marker::PhantomData<F>, +} + +impl<F> Weak<F> { + pub(crate) const fn new(name: &'static str) -> Self { + Self { + name, + addr: AtomicPtr::new(INVALID), + _marker: marker::PhantomData, + } + } + + pub(crate) fn get(&self) -> Option<F> { + assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); + unsafe { + // Relaxed is fine here because we fence before reading through the + // pointer (see the comment below). + match self.addr.load(Ordering::Relaxed) { + INVALID => self.initialize(), + NULL => None, + addr => { + let func = mem::transmute_copy::<*mut c_void, F>(&addr); + // The caller is presumably going to read through this value + // (by calling the function we've dlsymed). This means we'd + // need to have loaded it with at least C11's consume + // ordering in order to be guaranteed that the data we read + // from the pointer isn't from before the pointer was + // stored. Rust has no equivalent to memory_order_consume, + // so we use an acquire fence (sorry, ARM). + // + // Now, in practice this likely isn't needed even on CPUs + // where relaxed and consume mean different things. The + // symbols we're loading are probably present (or not) at + // init, and even if they aren't the runtime dynamic loader + // is extremely likely have sufficient barriers internally + // (possibly implicitly, for example the ones provided by + // invoking `mprotect`). + // + // That said, none of that's *guaranteed*, and so we fence. + atomic::fence(Ordering::Acquire); + Some(func) + } + } + } + } + + // Cold because it should only happen during first-time initialization. + #[cold] + unsafe fn initialize(&self) -> Option<F> { + let val = fetch(self.name); + // This synchronizes with the acquire fence in `get`. + self.addr.store(val, Ordering::Release); + + match val { + NULL => None, + addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)), + } + } +} + +unsafe fn fetch(name: &str) -> *mut c_void { + let name = match CStr::from_bytes_with_nul(name.as_bytes()) { + Ok(c_str) => c_str, + Err(..) => return null_mut(), + }; + libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr().cast()) +} + +#[cfg(not(any(target_os = "android", target_os = "linux")))] +macro_rules! syscall { + (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + unsafe fn $name($($arg_name: $t),*) -> $ret { + weak! { fn $name($($t),*) -> $ret } + + if let Some(fun) = $name.get() { + fun($($arg_name),*) + } else { + errno::set_errno(errno::Errno(libc::ENOSYS)); + -1 + } + } + ) +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +macro_rules! syscall { + (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + unsafe fn $name($($arg_name:$t),*) -> $ret { + // This looks like a hack, but concat_idents only accepts idents + // (not paths). + use libc::*; + + trait AsSyscallArg { + type SyscallArgType; + fn as_syscall_arg(self) -> Self::SyscallArgType; + } + + // Pass pointer types as pointers, to preserve provenance. + impl<T> AsSyscallArg for *mut T { + type SyscallArgType = *mut T; + fn as_syscall_arg(self) -> Self::SyscallArgType { self } + } + impl<T> AsSyscallArg for *const T { + type SyscallArgType = *const T; + fn as_syscall_arg(self) -> Self::SyscallArgType { self } + } + + // Pass `BorrowedFd` values as the integer value. + impl AsSyscallArg for $crate::fd::BorrowedFd<'_> { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { + $crate::fd::AsRawFd::as_raw_fd(&self) as _ + } + } + + // Coerce integer values into `c_long`. + impl AsSyscallArg for i32 { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + impl AsSyscallArg for u32 { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + impl AsSyscallArg for usize { + type SyscallArgType = c::c_long; + fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } + } + + syscall( + concat_idents!(SYS_, $name), + $($arg_name.as_syscall_arg()),* + ) as $ret + } + ) +} + +macro_rules! weakcall { + ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( + $vis unsafe fn $name($($arg_name: $t),*) -> $ret { + weak! { fn $name($($t),*) -> $ret } + + // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` + // interposition, but if it's not found just fail. + if let Some(fun) = $name.get() { + fun($($arg_name),*) + } else { + errno::set_errno(errno::Errno(libc::ENOSYS)); + -1 + } + } + ) +} diff --git a/vendor/rustix/tests/process/working_directory.rs b/vendor/rustix/tests/process/working_directory.rs new file mode 100644 index 000000000..1c3262bb9 --- /dev/null +++ b/vendor/rustix/tests/process/working_directory.rs @@ -0,0 +1,43 @@ +#![cfg(feature = "fs")] + +#[cfg(not(target_os = "macos"))] +use rustix::fs::{Mode, OFlags}; +use tempfile::{tempdir, TempDir}; + +#[allow(unused)] +fn tmpdir() -> TempDir { + tempdir().expect("expected to be able to create a temporary directory") +} + +/// Disable this test on macos because GHA has a weird system folder structure +/// that makes this test fail. +#[cfg(not(target_os = "macos"))] +#[test] +fn test_changing_working_directory() { + let tmpdir = tmpdir(); + + let orig_cwd = rustix::process::getcwd(Vec::new()).expect("get the cwd"); + let orig_fd_cwd = rustix::fs::openat(rustix::fs::cwd(), ".", OFlags::RDONLY, Mode::empty()) + .expect("get a fd for the current directory"); + + rustix::process::chdir(tmpdir.path()).expect("changing dir to the tmp"); + let ch1_cwd = rustix::process::getcwd(Vec::new()).expect("get the cwd"); + + assert_ne!(orig_cwd, ch1_cwd, "The cwd hasn't changed!"); + assert_eq!( + ch1_cwd.to_string_lossy(), + tmpdir.path().to_string_lossy(), + "The cwd is not the same as the tmpdir" + ); + + #[cfg(not(target_os = "fuchsia"))] + rustix::process::fchdir(orig_fd_cwd).expect("changing dir to the original"); + #[cfg(target_os = "fushcia")] + rustix::process::chdir(orig_cwd).expect("changing dir to the original"); + let ch2_cwd = rustix::process::getcwd(ch1_cwd).expect("get the cwd"); + + assert_eq!( + orig_cwd, ch2_cwd, + "The cwd wasn't changed back to the its original position" + ); +} diff --git a/vendor/rustix/tests/rand/getrandom.rs b/vendor/rustix/tests/rand/getrandom.rs new file mode 100644 index 000000000..ac316e447 --- /dev/null +++ b/vendor/rustix/tests/rand/getrandom.rs @@ -0,0 +1,7 @@ +use rustix::rand::{getrandom, GetRandomFlags}; + +#[test] +fn test_getrandom() { + let mut buf = [0_u8; 256]; + let _ = getrandom(&mut buf, GetRandomFlags::empty()); +} diff --git a/vendor/rustix/tests/rand/main.rs b/vendor/rustix/tests/rand/main.rs new file mode 100644 index 000000000..9dac8027f --- /dev/null +++ b/vendor/rustix/tests/rand/main.rs @@ -0,0 +1,9 @@ +//! Tests for [`rustix::rand`]. + +#![cfg(feature = "rand")] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] + +#[cfg(any(linux_raw, all(libc, target_os = "linux")))] +mod getrandom; diff --git a/vendor/rustix/tests/termios/isatty.rs b/vendor/rustix/tests/termios/isatty.rs new file mode 100644 index 000000000..5e6fae73d --- /dev/null +++ b/vendor/rustix/tests/termios/isatty.rs @@ -0,0 +1,69 @@ +use rustix::fd::AsRawFd; +use rustix::termios::{isatty, tcgetwinsize}; +use tempfile::{tempdir, TempDir}; + +#[allow(unused)] +fn tmpdir() -> TempDir { + tempdir().expect("expected to be able to create a temporary directory") +} + +#[test] +fn std_file_is_not_terminal() { + let tmpdir = tempfile::tempdir().unwrap(); + assert!(!isatty( + &std::fs::File::create(tmpdir.path().join("file")).unwrap() + )); + assert!(!isatty( + &std::fs::File::open(tmpdir.path().join("file")).unwrap() + )); +} + +#[test] +fn stdout_stderr_terminals() { + // This test is flaky under qemu. + if std::env::vars().any(|var| var.0.starts_with("CARGO_TARGET_") && var.0.ends_with("_RUNNER")) + { + return; + } + + // Compare `isatty` against `libc::isatty`. + assert_eq!(isatty(&std::io::stdout()), unsafe { + libc::isatty(std::io::stdout().as_raw_fd()) != 0 + }); + assert_eq!(isatty(&std::io::stderr()), unsafe { + libc::isatty(std::io::stderr().as_raw_fd()) != 0 + }); + + // Compare `isatty` against `tcgetwinsize`. + assert_eq!( + isatty(&std::io::stdout()), + tcgetwinsize(&std::io::stdout()).is_ok() + ); + assert_eq!( + isatty(&std::io::stderr()), + tcgetwinsize(&std::io::stderr()).is_ok() + ); +} + +#[test] +fn stdio_descriptors() { + #[cfg(unix)] + use std::os::unix::io::AsRawFd; + #[cfg(target_os = "wasi")] + use std::os::wasi::io::AsRawFd; + + unsafe { + assert_eq!( + rustix::io::stdin().as_raw_fd(), + std::io::stdin().as_raw_fd() + ); + assert_eq!( + rustix::io::stdout().as_raw_fd(), + std::io::stdout().as_raw_fd() + ); + assert_eq!( + rustix::io::stderr().as_raw_fd(), + std::io::stderr().as_raw_fd() + ); + } +} diff --git a/vendor/rustix/tests/termios/main.rs b/vendor/rustix/tests/termios/main.rs new file mode 100644 index 000000000..d9ad9338b --- /dev/null +++ b/vendor/rustix/tests/termios/main.rs @@ -0,0 +1,10 @@ +//! Tests for [`rustix::termios`]. + +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] +#![cfg(feature = "termios")] + +#[cfg(not(windows))] +mod isatty; +#[cfg(not(windows))] +mod ttyname; diff --git a/vendor/rustix/tests/termios/ttyname.rs b/vendor/rustix/tests/termios/ttyname.rs new file mode 100644 index 000000000..636178c31 --- /dev/null +++ b/vendor/rustix/tests/termios/ttyname.rs @@ -0,0 +1,24 @@ +use rustix::io; +use rustix::termios::{isatty, ttyname}; +use std::fs::File; + +#[test] +fn test_ttyname_ok() { + let file = File::open("/dev/stdin").unwrap(); + if isatty(&file) { + assert!(ttyname(&file, Vec::new()) + .unwrap() + .into_string() + .unwrap() + .starts_with("/dev/")); + } +} + +#[test] +fn test_ttyname_not_tty() { + let file = File::open("Cargo.toml").unwrap(); + assert_eq!(ttyname(&file, Vec::new()).unwrap_err(), io::Errno::NOTTY); + + let file = File::open("/dev/null").unwrap(); + assert_eq!(ttyname(&file, Vec::new()).unwrap_err(), io::Errno::NOTTY); +} diff --git a/vendor/rustix/tests/thread/clocks.rs b/vendor/rustix/tests/thread/clocks.rs new file mode 100644 index 000000000..cf14df777 --- /dev/null +++ b/vendor/rustix/tests/thread/clocks.rs @@ -0,0 +1,212 @@ +#[cfg(not(any( + target_os = "emscripten", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +use rustix::thread::{clock_nanosleep_absolute, clock_nanosleep_relative, ClockId}; +#[cfg(not(target_os = "redox"))] +use { + rustix::io, + rustix::thread::{nanosleep, NanosleepRelativeResult, Timespec}, +}; + +#[cfg(not(target_os = "redox"))] +#[test] +fn test_invalid_nanosleep() { + match nanosleep(&Timespec { + tv_sec: 0, + tv_nsec: 1_000_000_000, + }) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match nanosleep(&Timespec { + tv_sec: 0, + tv_nsec: !0, + }) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match nanosleep(&Timespec { + tv_sec: !0, + tv_nsec: 1_000_000_000, + }) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match nanosleep(&Timespec { + tv_sec: !0, + tv_nsec: !0, + }) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} + +#[cfg(not(any( + target_os = "emscripten", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +#[test] +fn test_invalid_nanosleep_absolute() { + match clock_nanosleep_absolute( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: 1000000000, + }, + ) { + Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_absolute( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: !0, + }, + ) { + Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_absolute( + ClockId::Monotonic, + &Timespec { + tv_sec: !0, + tv_nsec: 1_000_000_000, + }, + ) { + Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_absolute( + ClockId::Monotonic, + &Timespec { + tv_sec: !0, + tv_nsec: !0, + }, + ) { + Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} + +#[cfg(not(any( + target_os = "emscripten", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +#[test] +fn test_invalid_nanosleep_relative() { + match clock_nanosleep_relative( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: 1_000_000_000, + }, + ) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_relative( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: !0, + }, + ) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_relative( + ClockId::Monotonic, + &Timespec { + tv_sec: !0, + tv_nsec: 1_000_000_000, + }, + ) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } + match clock_nanosleep_relative( + ClockId::Monotonic, + &Timespec { + tv_sec: !0, + tv_nsec: !0, + }, + ) { + NanosleepRelativeResult::Err(io::Errno::INVAL) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} + +#[cfg(not(target_os = "redox"))] +#[test] +fn test_zero_nanosleep() { + match nanosleep(&Timespec { + tv_sec: 0, + tv_nsec: 0, + }) { + NanosleepRelativeResult::Ok => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} + +#[cfg(not(any( + target_os = "emscripten", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +#[test] +fn test_zero_nanosleep_absolute() { + match clock_nanosleep_absolute( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: 0, + }, + ) { + Ok(()) => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} + +#[cfg(not(any( + target_os = "emscripten", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "openbsd", + target_os = "redox", + target_os = "wasi", +)))] +#[test] +fn test_zero_nanosleep_relative() { + match clock_nanosleep_relative( + ClockId::Monotonic, + &Timespec { + tv_sec: 0, + tv_nsec: 0, + }, + ) { + NanosleepRelativeResult::Ok => (), + otherwise => panic!("unexpected resut: {:?}", otherwise), + } +} diff --git a/vendor/rustix/tests/thread/id.rs b/vendor/rustix/tests/thread/id.rs new file mode 100644 index 000000000..7aa5abba5 --- /dev/null +++ b/vendor/rustix/tests/thread/id.rs @@ -0,0 +1,7 @@ +use rustix::thread; + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_gettid() { + assert_eq!(thread::gettid(), thread::gettid()); +} diff --git a/vendor/rustix/tests/thread/main.rs b/vendor/rustix/tests/thread/main.rs new file mode 100644 index 000000000..0fc9b42c4 --- /dev/null +++ b/vendor/rustix/tests/thread/main.rs @@ -0,0 +1,9 @@ +//! Tests for [`rustix::thread`]. + +#![cfg(feature = "thread")] +#![cfg(not(windows))] + +#[cfg(not(any(target_os = "redox")))] +mod clocks; +#[cfg(any(target_os = "android", target_os = "linux"))] +mod id; diff --git a/vendor/rustix/tests/time/dynamic_clocks.rs b/vendor/rustix/tests/time/dynamic_clocks.rs new file mode 100644 index 000000000..a7e1e6792 --- /dev/null +++ b/vendor/rustix/tests/time/dynamic_clocks.rs @@ -0,0 +1,22 @@ +#![cfg(not(any(target_os = "redox", target_os = "wasi")))] + +use rustix::fd::AsFd; +use rustix::time::{clock_gettime_dynamic, ClockId, DynamicClockId}; + +#[test] +fn test_known_clocks() { + clock_gettime_dynamic(DynamicClockId::Known(ClockId::Realtime)).unwrap(); + clock_gettime_dynamic(DynamicClockId::Known(ClockId::Monotonic)).unwrap(); +} + +#[test] +fn test_dynamic_clocks() { + let file = std::fs::File::open("Cargo.toml").unwrap(); + clock_gettime_dynamic(DynamicClockId::Dynamic(file.as_fd())).unwrap_err(); +} + +#[cfg(any(target_os = "android", target_os = "linux"))] +#[test] +fn test_conditional_clocks() { + let _ = clock_gettime_dynamic(DynamicClockId::Tai); +} diff --git a/vendor/rustix/tests/time/main.rs b/vendor/rustix/tests/time/main.rs new file mode 100644 index 000000000..43283bca2 --- /dev/null +++ b/vendor/rustix/tests/time/main.rs @@ -0,0 +1,14 @@ +//! Tests for [`rustix::time`]. + +#![cfg(feature = "time")] +#![cfg(not(windows))] +#![cfg_attr(target_os = "wasi", feature(wasi_ext))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] + +mod dynamic_clocks; +#[cfg(not(any(target_os = "redox", target_os = "wasi")))] +mod monotonic; +#[cfg(any(target_os = "android", target_os = "linux"))] +mod timerfd; +mod timespec; +mod y2038; diff --git a/vendor/rustix/tests/time/monotonic.rs b/vendor/rustix/tests/time/monotonic.rs new file mode 100644 index 000000000..89470f2b4 --- /dev/null +++ b/vendor/rustix/tests/time/monotonic.rs @@ -0,0 +1,45 @@ +#[cfg(feature = "thread")] +use rustix::thread::nanosleep; +use rustix::time::{clock_gettime, ClockId, Timespec}; + +/// Attempt to test that the monotonic clock is monotonic. Time may or may not +/// advance, but it shouldn't regress. +#[test] +fn test_monotonic_clock() { + let a = clock_gettime(ClockId::Monotonic); + let b = clock_gettime(ClockId::Monotonic); + if b.tv_sec == a.tv_sec { + assert!(b.tv_nsec >= a.tv_nsec); + } else { + assert!(b.tv_sec > a.tv_sec); + } +} + +/// With the "thread" feature, we can sleep so that we're guaranteed that time +/// has advanced. +#[cfg(feature = "thread")] +#[test] +fn test_monotonic_clock_with_sleep_1s() { + let a = clock_gettime(ClockId::Monotonic); + let _rem = nanosleep(&Timespec { + tv_sec: 1, + tv_nsec: 0, + }); + let b = clock_gettime(ClockId::Monotonic); + assert!(b.tv_sec > a.tv_sec); +} + +/// With the "thread" feature, we can sleep so that we're guaranteed that time +/// has advanced. +#[cfg(feature = "thread")] +#[test] +fn test_monotonic_clock_with_sleep_1ms() { + let a = clock_gettime(ClockId::Monotonic); + let _rem = nanosleep(&Timespec { + tv_sec: 0, + tv_nsec: 1_000_000, + }); + let b = clock_gettime(ClockId::Monotonic); + assert!(b.tv_sec >= a.tv_sec); + assert!(b.tv_sec != a.tv_sec || b.tv_nsec > a.tv_nsec); +} diff --git a/vendor/rustix/tests/time/timerfd.rs b/vendor/rustix/tests/time/timerfd.rs new file mode 100644 index 000000000..6ad4dd72e --- /dev/null +++ b/vendor/rustix/tests/time/timerfd.rs @@ -0,0 +1,75 @@ +use rustix::time::{ + timerfd_create, timerfd_gettime, timerfd_settime, Itimerspec, TimerfdClockId, TimerfdFlags, + TimerfdTimerFlags, Timespec, +}; + +#[test] +fn test_timerfd() { + let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); + + let set = Itimerspec { + it_interval: Timespec { + tv_sec: 0, + tv_nsec: 0, + }, + it_value: Timespec { + tv_sec: 1, + tv_nsec: 2, + }, + }; + let _old: Itimerspec = timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set).unwrap(); + + // Wait for the timer to expire. + let mut buf = [0_u8; 8]; + assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); + assert!(u64::from_ne_bytes(buf) >= 1); + + let new = timerfd_gettime(&fd).unwrap(); + + // The timer counts down. + assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); + assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); + assert!(new.it_value.tv_sec <= set.it_value.tv_sec); + assert!( + new.it_value.tv_nsec < set.it_value.tv_nsec || new.it_value.tv_sec < set.it_value.tv_sec + ); +} + +/// Similar, but set an interval for a repeated timer. Don't check that the +/// times are monotonic because that would race with the timer repeating. +#[test] +fn test_timerfd_with_interval() { + let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); + + let set = Itimerspec { + it_interval: Timespec { + tv_sec: 0, + tv_nsec: 6, + }, + it_value: Timespec { + tv_sec: 1, + tv_nsec: 7, + }, + }; + let _old: Itimerspec = timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set).unwrap(); + + // Wait for the timer to expire. + let mut buf = [0_u8; 8]; + assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); + assert!(u64::from_ne_bytes(buf) >= 1); + + let new = timerfd_gettime(&fd).unwrap(); + + assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); + assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); + + // Wait for the timer to expire again. + let mut buf = [0_u8; 8]; + assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); + assert!(u64::from_ne_bytes(buf) >= 1); + + let new = timerfd_gettime(&fd).unwrap(); + + assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); + assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); +} diff --git a/vendor/rustix/tests/time/timespec.rs b/vendor/rustix/tests/time/timespec.rs new file mode 100644 index 000000000..6d892dcfe --- /dev/null +++ b/vendor/rustix/tests/time/timespec.rs @@ -0,0 +1,26 @@ +#[test] +fn test_timespec_layout() { + #[cfg(not(target_os = "redox"))] + use rustix::fs::{UTIME_NOW, UTIME_OMIT}; + use rustix::time::{Nsecs, Secs, Timespec}; + + let tv_sec: Secs = 0; + let tv_nsec: Nsecs = 0; + let _ = Timespec { tv_sec, tv_nsec }; + + #[cfg(not(target_os = "redox"))] + let _ = Timespec { + tv_sec, + tv_nsec: UTIME_NOW, + }; + #[cfg(not(target_os = "redox"))] + let _ = Timespec { + tv_sec, + tv_nsec: UTIME_OMIT, + }; + let _ = Timespec { tv_sec, tv_nsec: 0 }; + let _ = Timespec { + tv_sec, + tv_nsec: 999_999_999, + }; +} diff --git a/vendor/rustix/tests/time/y2038.rs b/vendor/rustix/tests/time/y2038.rs new file mode 100644 index 000000000..45a073d19 --- /dev/null +++ b/vendor/rustix/tests/time/y2038.rs @@ -0,0 +1,77 @@ +/// Test that `Timespec` and `Secs` support a 64-bit number of seconds, +/// avoiding the y2038 bug. +/// +/// The Rust Musl target and libc crate are currently using Musl 1.1. It is +/// expected to update to Musl 1.2 at some point, at which point it'll gain a +/// 64-bit `time_t`. +/// +/// 32-bit Android is [not y2038 compatible]. In theory we could use +/// `libc::syscall` and call the new syscalls ourselves, however that doesn't +/// seem worth the effort on a platform that will likely never support add +/// such support itself. +/// +/// [not y2038 compatible]: https://android.googlesource.com/platform/bionic/+/refs/heads/master/docs/32-bit-abi.md#is-32_bit-on-lp32-y2038 +#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] +#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] +#[test] +fn test_y2038() { + use rustix::time::{Secs, Timespec}; + + let tv_sec: i64 = 0; + let _ = Timespec { tv_sec, tv_nsec: 0 }; + let _: Secs = tv_sec; + + #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] + { + use rustix::time::Itimerspec; + + let _ = Itimerspec { + it_interval: Timespec { tv_sec, tv_nsec: 0 }, + it_value: Timespec { tv_sec, tv_nsec: 0 }, + }; + } +} + +#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] +#[test] +fn test_y2038_with_timerfd() { + use rustix::time::{ + timerfd_create, timerfd_gettime, timerfd_settime, Itimerspec, TimerfdClockId, TimerfdFlags, + TimerfdTimerFlags, Timespec, + }; + + let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); + + let set = Itimerspec { + it_interval: Timespec { + tv_sec: (1_u64 << 32) as _, + tv_nsec: 20, + }, + it_value: Timespec { + tv_sec: (1_u64 << 32) as _, + tv_nsec: 21, + }, + }; + let _old: Itimerspec = match timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set) { + Ok(i) => i, + + // On 32-bit and mips64 platforms, accept `EOVERFLOW`, meaning that + // y2038 support in `timerfd` APIs is not available on this platform + // or this version of the platform. + #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))] + Err(rustix::io::Errno::OVERFLOW) => return, + + Err(e) => panic!("unexpected error: {:?}", e), + }; + + let new = timerfd_gettime(&fd).unwrap(); + + // The timer counts down. + assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); + assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); + assert!(new.it_value.tv_sec <= set.it_value.tv_sec); + assert!( + new.it_value.tv_nsec < set.it_value.tv_nsec || new.it_value.tv_sec < set.it_value.tv_sec + ); +} |