blob: edbfd54a83358673ca8119567f28b5572446f47b [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::{
capi::error as capi_error,
error::{ErrorExt, ErrorKind},
tests::traits::ErrorImpl,
};
use std::{
cmp,
ffi::{CStr, CString, OsStr},
fmt,
os::unix::{
ffi::OsStrExt,
io::{FromRawFd, OwnedFd},
},
path::{Path, PathBuf},
ptr,
};
use errno::Errno;
#[derive(Debug, Clone, thiserror::Error)]
pub struct CapiError {
errno: Option<Errno>,
description: String,
}
impl fmt::Display for CapiError {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{}", self.description)?;
if let Some(errno) = self.errno {
write!(fmt, " ({errno})")?;
}
Ok(())
}
}
impl ErrorExt for CapiError {
fn with_wrap<F>(self, context_fn: F) -> Self
where
F: FnOnce() -> String,
{
Self {
errno: self.errno,
description: context_fn() + ": " + &self.description,
}
}
}
impl ErrorImpl for CapiError {
fn kind(&self) -> ErrorKind {
if let Some(errno) = self.errno {
ErrorKind::OsError(Some(errno.0))
} else {
// TODO: We should probably have an actual "no-op" error here that
// is unused except for these tests so we can properly detect
// a bad ErrorKind.
ErrorKind::InternalError
}
}
}
fn fetch_error(res: libc::c_int) -> Result<libc::c_int, CapiError> {
if res >= 0 {
Ok(res)
} else {
// SAFETY: pathrs_errorinfo is safe to call in general.
match unsafe { capi_error::pathrs_errorinfo(res) } {
Some(err) => {
let errno = match err.saved_errno as i32 {
0 => None,
errno => Some(Errno(errno)),
};
// SAFETY: pathrs_errorinfo returns a valid string pointer. We
// can't take ownership because pathrs_errorinfo_free() will do
// the freeing for us.
let description = unsafe { CStr::from_ptr(err.description) }
.to_string_lossy()
.to_string();
// Free the error from the error map, now that we copied the
// contents.
// SAFETY: We are the only ones holding a reference to the err
// pointer and don't touch it later, so we can free it freely.
unsafe { capi_error::pathrs_errorinfo_free(err as *mut _) }
Err(CapiError { errno, description })
}
None => panic!("unknown error id {res}"),
}
}
}
pub(in crate::tests) fn path_to_cstring(path: impl AsRef<Path>) -> CString {
CString::new(path.as_ref().as_os_str().as_bytes())
.expect("normal path conversion shouldn't result in spurious nul bytes")
}
pub(in crate::tests) fn call_capi<Func>(func: Func) -> Result<libc::c_int, CapiError>
where
Func: Fn() -> libc::c_int,
{
fetch_error(func())
}
pub(in crate::tests) fn call_capi_zst<Func>(func: Func) -> Result<(), CapiError>
where
Func: Fn() -> libc::c_int,
{
call_capi(func).map(|val| {
assert_eq!(
val, 0,
"call_capi_zst must only be called on methods that return <= 0: got {val}"
);
})
}
pub(in crate::tests) fn call_capi_fd<Func>(func: Func) -> Result<OwnedFd, CapiError>
where
Func: Fn() -> libc::c_int,
{
// SAFETY: The caller has guaranteed us that the closure will return an fd.
call_capi(func).map(|fd| unsafe { OwnedFd::from_raw_fd(fd) })
}
pub(in crate::tests) fn call_capi_readlink<Func>(func: Func) -> Result<PathBuf, CapiError>
where
Func: Fn(*mut libc::c_char, libc::size_t) -> libc::c_int,
{
// Get the actual size by passing NULL.
let actual_size = {
// Try zero-size.
let size1 = fetch_error(func(123 as *mut _, 0))? as usize;
// Try NULL ptr.
let size2 = fetch_error(func(ptr::null_mut(), 1000))? as usize;
assert_eq!(size1, size2, "readlink size should be the same");
size1
};
// Wrapper around func() to allow for us to call it with different sizes.
let readlink_func = |size| -> Result<PathBuf, CapiError> {
let mut linkbuf: Vec<u8> = Vec::with_capacity(size);
let got_size = fetch_error(func(
linkbuf.as_mut_ptr() as *mut libc::c_char,
linkbuf.capacity(),
))? as usize;
// SAFETY: The C-API readlink methods return the number of bytes it
// would take to store the data. If this is >capacity then the entire
// array was filled (and data was truncated), otherwise it indicates how
// many bytes were filled.
unsafe { linkbuf.set_len(cmp::min(got_size, linkbuf.capacity())) };
// readlink does *not* append a null terminator!
Ok(OsStr::from_bytes(
CString::new(linkbuf)
.expect("constructing a CString from the C API's copied CString should work")
.to_bytes(),
)
.into())
};
// Get the actual link with the exactly correct buffer size.
let actual_linktarget = readlink_func(actual_size)?;
// Try to see different results and make sure they are actually truncated as
// expected.
// TODO: Maybe make this property-based? A bit ugly because this is being
// done deep within other tests... :/
for test_size in [
1,
2,
actual_size / 3,
actual_size / 2,
actual_size - 1, // actual_size must be > 0 -- symlinks cannot be empty
actual_size + 1,
actual_size + 2,
actual_size * 2,
] {
let test_linktarget = readlink_func(test_size)?;
if test_size >= actual_size {
assert_eq!(
actual_linktarget,
test_linktarget,
"readlink(linkbuf_len={test_size} >= actual_size={actual_size}) should return the same link target string",
);
} else {
let actual_linktarget_truncated =
OsStr::from_bytes(&actual_linktarget.as_os_str().as_bytes()[..test_size]);
assert_eq!(
actual_linktarget_truncated,
test_linktarget.as_os_str(),
"readlink(linkbuf_len={test_size} < actual_size={actual_size}) should truncate link target string to {test_size} bytes",
);
}
}
Ok(actual_linktarget)
}