blob: 4eccbbe823ee4154e62f0217430ac7d24b25122f [file] [edit]
// 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::{Error, ErrorExt, ErrorImpl},
flags::OpenFlags,
procfs::{ProcfsBase, ProcfsHandle},
};
use std::{
io::{BufRead, BufReader},
path::PathBuf,
str::FromStr,
};
pub(crate) fn sysctl_read_parse<T>(procfs: &ProcfsHandle, sysctl: &str) -> Result<T, Error>
where
T: FromStr,
T::Err: Into<ErrorImpl> + Into<Error>,
{
// "/proc/sys"
let mut sysctl_path = PathBuf::from("sys");
// Convert "foo.bar.baz" to "foo/bar/baz".
sysctl_path.push(sysctl.replace(".", "/"));
let sysctl_file = procfs.open(ProcfsBase::ProcRoot, sysctl_path, OpenFlags::O_RDONLY)?;
// Just read the first line.
let mut reader = BufReader::new(sysctl_file);
let mut line = String::new();
reader
.read_line(&mut line)
.map_err(|err| ErrorImpl::OsError {
operation: format!("read first line of {sysctl:?} sysctl").into(),
source: err,
})?;
// Strip newlines.
line.trim_end_matches("\n")
.parse()
.map_err(Error::from)
.with_wrap(|| {
format!(
"could not parse sysctl {sysctl:?} as {:?}",
std::any::type_name::<T>()
)
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
error::{Error, ErrorKind},
procfs::ProcfsHandle,
tests::common as tests_common,
};
use once_cell::sync::Lazy;
use pretty_assertions::assert_eq;
// MSRV(1.80): Use LazyLock.
static TEST_PROCFS_HANDLE: Lazy<ProcfsHandle> =
Lazy::new(|| ProcfsHandle::new().expect("should be able to get some /proc handle"));
#[test]
fn bad_sysctl_file_noexist() {
// FIXME(libtest skip): use proper runtime skipping in the test.
#[allow(clippy::unused_unit)]
{
tests_common::hotfix_skip_if_proc_sys_overmounts!(return ());
}
assert_eq!(
sysctl_read_parse::<String>(&TEST_PROCFS_HANDLE, "nonexistent.dummy.sysctl.path")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::OsError(Some(libc::ENOENT))),
"reading line from non-existent sysctl",
);
assert_eq!(
sysctl_read_parse::<u32>(&TEST_PROCFS_HANDLE, "nonexistent.sysctl.path")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::OsError(Some(libc::ENOENT))),
"parsing line from non-existent sysctl",
);
}
#[test]
fn bad_sysctl_file_noread() {
// FIXME(libtest skip): use proper runtime skipping in the test.
#[allow(clippy::unused_unit)]
{
tests_common::hotfix_skip_if_proc_sys_overmounts!(return ());
}
assert_eq!(
sysctl_read_parse::<String>(&TEST_PROCFS_HANDLE, "vm.drop_caches")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::OsError(Some(libc::EACCES))),
"reading line from non-readable sysctl",
);
assert_eq!(
sysctl_read_parse::<u32>(&TEST_PROCFS_HANDLE, "vm.drop_caches")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::OsError(Some(libc::EACCES))),
"parse line from non-readable sysctl",
);
}
#[test]
fn bad_sysctl_parse_invalid_multinumber() {
// FIXME(libtest skip): use proper runtime skipping in the test.
#[allow(clippy::unused_unit)]
{
tests_common::hotfix_skip_if_proc_sys_overmounts!(return ());
}
assert!(sysctl_read_parse::<String>(&TEST_PROCFS_HANDLE, "kernel.printk").is_ok());
assert_eq!(
sysctl_read_parse::<u32>(&TEST_PROCFS_HANDLE, "kernel.printk")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::InternalError),
"parsing line from multi-number sysctl",
);
}
#[test]
fn bad_sysctl_parse_invalid_nonnumber() {
// FIXME(libtest skip): use proper runtime skipping in the test.
#[allow(clippy::unused_unit)]
{
tests_common::hotfix_skip_if_proc_sys_overmounts!(return ());
}
assert!(sysctl_read_parse::<String>(&TEST_PROCFS_HANDLE, "kernel.random.uuid").is_ok());
assert_eq!(
sysctl_read_parse::<u32>(&TEST_PROCFS_HANDLE, "kernel.random.uuid")
.as_ref()
.map_err(Error::kind),
Err(ErrorKind::InternalError),
"parsing line from non-number sysctl",
);
}
#[test]
fn sysctl_parse_int() {
// FIXME(libtest skip): use proper runtime skipping in the test.
#[allow(clippy::unused_unit)]
{
tests_common::hotfix_skip_if_proc_sys_overmounts!(return ());
}
assert!(sysctl_read_parse::<String>(&TEST_PROCFS_HANDLE, "kernel.pid_max").is_ok());
assert!(sysctl_read_parse::<u64>(&TEST_PROCFS_HANDLE, "kernel.pid_max").is_ok());
}
}