blob: 77f7d4afc37f206c1b4a794c6fc7b07d1183838c [file]
// SPDX-License-Identifier: MPL-2.0 OR LGPL-3.0-or-later
/*
* libpathrs: safe path resolution on Linux
* Copyright (C) 2019-2025 SUSE LLC
* Copyright (C) 2026 Aleksa Sarai <cyphar@cyphar.com>
*
* == MPL-2.0 ==
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*
* Alternatively, this Source Code Form may also (at your option) be used
* under the terms of the GNU Lesser General Public License Version 3, as
* described below:
*
* == LGPL-3.0-or-later ==
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use crate::{
error::ErrorKind,
flags::OpenFlags,
resolvers::PartialLookup,
tests::{common as tests_common, traits::HandleImpl},
utils::FdExt,
};
use std::os::unix::{fs::MetadataExt, io::AsFd};
use anyhow::{Context, Error};
use pretty_assertions::assert_eq;
use rustix::{
fs::{self as rustix_fs, Mode, OFlags},
io::{self as rustix_io, FdFlags},
process::{self as rustix_process},
};
pub type LookupResult<'a> = (&'a str, libc::mode_t);
impl<H, E> PartialLookup<H, E> {
pub(in crate::tests) fn as_inner_handle(&self) -> &H {
match self {
PartialLookup::Complete(handle) => handle,
PartialLookup::Partial { handle, .. } => handle,
}
}
}
pub(in crate::tests) trait AsError<E> {
fn as_error(&self) -> Option<&E>;
}
impl<H, E> AsError<E> for Result<PartialLookup<H, E>, E> {
fn as_error(&self) -> Option<&E> {
match self {
Ok(PartialLookup::Complete(_)) => None,
Ok(PartialLookup::Partial { last_error, .. }) => Some(last_error),
Err(err) => Some(err),
}
}
}
impl<H, E> PartialEq for PartialLookup<H, E>
where
H: PartialEq,
E: PartialEq,
{
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Complete(left), Self::Complete(right)) => left == right,
(
Self::Partial {
handle: left_handle,
remaining: left_remaining,
last_error: left_last_error,
},
Self::Partial {
handle: right_handle,
remaining: right_remaining,
last_error: right_last_error,
},
) => {
left_handle == right_handle
&& left_remaining == right_remaining
&& left_last_error == right_last_error
}
_ => false,
}
}
}
pub(in crate::tests) fn check_mode(fd: impl AsFd, create_mode: u32) -> Result<(), Error> {
let fd = fd.as_fd();
// Get the umask.
let umask = {
let umask = rustix_process::umask(Mode::empty());
rustix_process::umask(umask);
umask.bits()
};
let got_mode = fd.metadata().context("fstat fd to check mode")?.mode()
// Strip type bits from mode if the caller didn't include them.
& !if create_mode & libc::S_IFMT == 0 {
libc::S_IFMT
} else {
0
};
assert_eq!(
create_mode & !umask,
got_mode,
"created fd {:?} should have mode {} ({create_mode} &^ {umask})",
fd.as_unsafe_path_unchecked().expect("get real path of fd"),
create_mode & !umask
);
Ok(())
}
pub(in crate::tests) fn check_oflags(fd: impl AsFd, flags: OpenFlags) -> Result<(), Error> {
let fd = fd.as_fd();
// Convert to OFlags so we can compare them.
let mut wanted_flags: OFlags = flags
.try_into()
.expect("OpenFlags should be convertible to rustix OFlags");
// O_CLOEXEC is always automatically enabled by libpathrs.
wanted_flags.insert(OFlags::CLOEXEC);
// The kernel clears several flags from f_flags in do_dentry_open(), so we
// need to drop them from the expected flag set.
wanted_flags.remove(OFlags::CREATE | OFlags::EXCL | OFlags::NOCTTY | OFlags::TRUNC);
// The O_PATH one-shot resolver (i.e., resolvers::procfs::opath_resolve)
// will add O_NOFOLLOW silently to returned files and there isn't a way for
// us to remove this (F_SETFL silently masks O_NOFOLLOW so we cannot clear
// it). So, add O_NOFOLLOW to the wanted flags if it is set. For a returned
// file, O_NOFOLLOW makes no practical difference anyway (and our tests
// check for the actually opened file anyway).
let got_file_flags = rustix_fs::fcntl_getfl(fd).context("failed to F_GETFL")?;
if got_file_flags.contains(OFlags::NOFOLLOW) {
wanted_flags.insert(OFlags::NOFOLLOW)
}
// Check regular file flags.
assert_eq!(
// Ignore O_LARGEFILE since it's basically a kernel internal.
got_file_flags & !OFlags::LARGEFILE,
// O_CLOEXEC is represented in the fd flags, not file flags.
wanted_flags & !OFlags::CLOEXEC,
"expected the reopened file's flags to match the requested flags"
);
// Check fd flags (namely O_CLOEXEC).
let got_fd_flags = rustix_io::fcntl_getfd(fd).context("failed to F_GETFD")?;
assert_eq!(
got_fd_flags.contains(FdFlags::CLOEXEC),
wanted_flags.contains(OFlags::CLOEXEC),
"expected the reopened file's O_CLOEXEC to be correct (oflags: {flags:?})",
);
assert!(
got_fd_flags.difference(FdFlags::CLOEXEC).is_empty(),
"expected fd flags to not contain anything other than FD_CLOEXEC (got flags: 0x{:x})",
got_fd_flags.bits()
);
Ok(())
}
pub(in crate::tests) fn check_reopen<H: HandleImpl>(
handle: H,
flags: OpenFlags,
expected_error: Option<i32>,
) -> Result<(), Error> {
let expected_error = match expected_error {
None => Ok(()),
Some(errno) => Err(ErrorKind::OsError(Some(errno))),
};
let file = match (handle.reopen(flags), expected_error) {
(Ok(f), Ok(_)) => f,
(result, expected) => {
let result = match result {
Ok(file) => Ok(file
.as_unsafe_path_unchecked()
.context("get real path of reopened file")?),
Err(err) => Err(err),
};
tests_common::check_err(&result, &expected)
.with_context(|| format!("reopen handle {flags:?}"))?;
assert!(
result.is_err(),
"we should never see an Ok(file) after check_err if we expected {expected:?}"
);
return Ok(());
}
};
let real_handle_path = handle
.as_unsafe_path_unchecked()
.context("get real path of handle")?;
let real_reopen_path = file
.as_unsafe_path_unchecked()
.context("get real path of reopened file")?;
assert_eq!(
real_handle_path, real_reopen_path,
"reopened handle should be equivalent to old handle",
);
let clone_handle = handle.try_clone().context("clone handle")?;
let clone_handle_path = clone_handle
.as_unsafe_path_unchecked()
.context("get real path of cloned handle")?;
assert_eq!(
real_handle_path, clone_handle_path,
"cloned handle should be equivalent to old handle",
);
check_oflags(
&file,
// NOTE: Handle::reopen() drops O_NOFOLLOW, so we shouldn't see it.
flags.difference(OpenFlags::O_NOFOLLOW),
)
.context("check reopened file flags")?;
Ok(())
}