Files
rust-discovery/crates/agent-linux/src/inventory.rs
T
BuTzZ 6c3203d725
Rust development slice / linux (push) Failing after 1m10s
feat: snapshot Linux-first RMM MVP and pause handover
2026-11-12 22:06:25 +01:00

1398 lines
48 KiB
Rust

//! Passive, bounded Linux observations. No refresh/update or configuration writes.
//! `received_at` is intentionally absent: the authenticated server assigns it.
use crate::{
actions::{ServiceUnit, reboot_required},
process,
};
use std::{
collections::BTreeMap,
ffi::{CStr, CString},
fs,
io::Read,
mem::MaybeUninit,
net::{Ipv4Addr, Ipv6Addr},
path::Path,
time::{Duration, SystemTime},
};
fn serialize_time<S: serde::Serializer>(
time: &SystemTime,
serializer: S,
) -> Result<S::Ok, S::Error> {
serde::Serialize::serialize(&chrono::DateTime::<chrono::Utc>::from(*time), serializer)
}
fn serialize_optional_time<S: serde::Serializer>(
time: &Option<SystemTime>,
serializer: S,
) -> Result<S::Ok, S::Error> {
serde::Serialize::serialize(&time.map(chrono::DateTime::<chrono::Utc>::from), serializer)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Quality {
Valid,
Unknown,
Unsupported,
PermissionDenied,
Error,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Completeness {
Complete,
Partial,
Unknown,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Observation<T> {
pub source_id: String,
#[serde(serialize_with = "serialize_time")]
pub observed_at: SystemTime,
pub quality: Quality,
pub completeness: Completeness,
pub truncated: bool,
pub error_code: Option<String>,
pub data: Option<T>,
}
impl<T> Observation<T> {
fn valid(source: &str, data: T) -> Self {
Self {
source_id: source.into(),
observed_at: SystemTime::now(),
quality: Quality::Valid,
completeness: Completeness::Complete,
truncated: false,
error_code: None,
data: Some(data),
}
}
fn unavailable(source: &str, quality: Quality, code: &str) -> Self {
let quality = if quality == Quality::Valid {
Quality::Unknown
} else {
quality
};
Self {
source_id: source.into(),
observed_at: SystemTime::now(),
quality,
completeness: Completeness::Unknown,
truncated: false,
error_code: Some(code.into()),
data: None,
}
}
fn partial(mut self, code: &str) -> Self {
self.completeness = Completeness::Partial;
self.error_code = Some(code.into());
self
}
}
fn read(path: &str, cap: usize) -> Observation<String> {
match fs::File::open(path).and_then(|f| {
let mut bytes = vec![];
f.take(cap as u64 + 1).read_to_end(&mut bytes)?;
Ok(bytes)
}) {
Ok(mut bytes) => {
let truncated = bytes.len() > cap;
bytes.truncate(cap);
match String::from_utf8(bytes) {
Ok(text) => {
let mut observation = Observation::valid(path, text);
if truncated {
observation = observation.partial("SOURCE_LIMIT");
observation.truncated = true;
}
observation
}
Err(_) => Observation::unavailable(path, Quality::Error, "NON_UTF8_SOURCE"),
}
}
Err(e) => Observation::unavailable(
path,
match e.kind() {
std::io::ErrorKind::PermissionDenied => Quality::PermissionDenied,
std::io::ErrorKind::NotFound => Quality::Unsupported,
_ => Quality::Error,
},
"SOURCE_UNREADABLE",
),
}
}
fn map<T, U>(source: Observation<T>, parse: impl FnOnce(T) -> Option<U>) -> Observation<U> {
let data = source.data.and_then(parse);
let failed = data.is_none() && source.quality == Quality::Valid;
Observation {
source_id: source.source_id,
observed_at: source.observed_at,
quality: if failed {
Quality::Error
} else {
source.quality
},
completeness: if failed {
Completeness::Unknown
} else {
source.completeness
},
truncated: source.truncated,
error_code: if failed {
Some("SOURCE_PARSE_ERROR".into())
} else {
source.error_code
},
data,
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Cpu {
pub logical_processors: usize,
pub model: Option<String>,
/// Cumulative jiffies, not a fabricated instant utilization percentage.
pub aggregate_jiffies: Vec<u64>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Memory {
pub total_bytes: u64,
pub available_bytes: Option<u64>,
pub swap_total_bytes: u64,
pub swap_free_bytes: u64,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct OperatingSystem {
pub release: BTreeMap<String, String>,
pub kernel: String,
pub architecture: String,
pub hostname: String,
pub boot_id: String,
pub uptime_seconds: f64,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Interface {
pub name: String,
pub addresses: Vec<String>,
pub mac: Option<String>,
pub operstate: Option<String>,
pub rx_bytes: Option<u64>,
pub tx_bytes: Option<u64>,
pub mtu: Option<u64>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Route {
pub interface: String,
pub destination: String,
pub gateway: String,
pub mask_or_prefix: String,
pub flags: u32,
pub metric: u32,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Dns {
pub nameservers: Vec<String>,
pub search: Vec<String>,
pub resolver_symlink: Option<String>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Volume {
pub mount_point: String,
pub filesystem: String,
pub device: String,
pub total_bytes: u64,
pub free_bytes: u64,
pub available_bytes: u64,
pub available_percent: Option<f64>,
pub total_inodes: u64,
pub free_inodes: u64,
pub available_inodes: u64,
pub available_inode_percent: Option<f64>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SoftwarePackage {
pub name: String,
pub version: String,
pub architecture: String,
pub status: String,
}
#[derive(Debug, Clone)]
pub struct ServiceStatus {
pub unit: ServiceUnit,
pub id: String,
pub load_state: String,
pub active_state: String,
pub sub_state: String,
pub unit_file_state: String,
}
#[derive(Debug, Clone)]
pub struct ServiceExpectation {
pub unit: ServiceUnit,
pub expected_active: bool,
}
#[derive(Debug, Clone)]
pub struct ServiceCheck {
pub expectation: ServiceExpectation,
pub status: Observation<ServiceStatus>,
pub matches: Option<bool>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AvailableUpdate {
pub package: String,
pub architecture: String,
pub candidate_version: String,
pub installed_version: Option<String>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct UpdateStatus {
pub available: Vec<AvailableUpdate>,
/// Local metadata file age is NOT an exact last scan or last install time.
#[serde(serialize_with = "serialize_optional_time")]
pub newest_local_metadata_at: Option<SystemTime>,
#[serde(serialize_with = "serialize_optional_time")]
pub last_successful_scan_at: Option<SystemTime>,
pub metadata_fresh: Option<bool>,
pub reboot_required: Option<bool>,
pub history_quality: Quality,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Hardware {
pub readable_dmi: BTreeMap<String, String>,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LinuxInventory {
pub os: Observation<OperatingSystem>,
pub cpu: Observation<Cpu>,
pub memory: Observation<Memory>,
pub interfaces: Observation<Vec<Interface>>,
pub routes: Observation<Vec<Route>>,
pub dns: Observation<Dns>,
pub volumes: Observation<Vec<Observation<Volume>>>,
pub software: Observation<Vec<SoftwarePackage>>,
pub updates: Observation<UpdateStatus>,
pub hardware: Observation<Hardware>,
pub smart: Observation<()>,
}
pub fn collect_native() -> LinuxInventory {
LinuxInventory {
os: operating_system(),
cpu: cpu(),
memory: memory(),
interfaces: interfaces(),
routes: routes(),
dns: dns(),
volumes: volumes(),
software: software(),
updates: updates(),
hardware: hardware(),
smart: Observation::unavailable(
"linux.smart",
Quality::Unsupported,
"NO_VERIFIED_READ_ONLY_SMART_PROVIDER",
),
}
}
/// Local availability only, not a production support/VM acceptance claim and
/// never evidence of authority to execute an operation.
pub fn capabilities() -> BTreeMap<String, Observation<bool>> {
use std::os::unix::fs::PermissionsExt;
let executable = |path: &str| {
fs::metadata(path).is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
};
let mut result = BTreeMap::new();
for (name, available, source) in [
(
"inventory.proc",
Path::new("/proc/meminfo").is_file(),
"/proc",
),
(
"software.dpkg",
executable("/usr/bin/dpkg-query"),
"/usr/bin/dpkg-query",
),
(
"updates.local_apt",
executable("/usr/bin/apt-cache") && executable("/usr/bin/apt"),
"local APT metadata",
),
(
"services.systemd",
Path::new("/run/systemd/system").is_dir() && executable("/usr/bin/systemctl"),
"systemd runtime",
),
(
"logs.journald",
executable("/usr/bin/journalctl")
&& (Path::new("/run/systemd/journal").is_dir()
|| Path::new("/var/log/journal").is_dir()),
"journald runtime",
),
(
"scripts.posix_sh",
crate::actions::Interpreter::PosixSh.available(),
"/bin/sh",
),
(
"scripts.bash",
crate::actions::Interpreter::Bash.available(),
"/bin/bash",
),
] {
let observation = if available {
Observation::valid(source, true)
} else {
Observation {
data: Some(false),
..Observation::unavailable(
source,
Quality::Unsupported,
"LOCAL_PROVIDER_UNAVAILABLE",
)
}
};
result.insert(name.into(), observation);
}
result.insert(
"packages.mutation".into(),
Observation {
data: Some(false),
..Observation::unavailable(
"linux.apt-helper",
Quality::Unsupported,
"ISOLATED_NO_REBOOT_HELPER_NOT_INTEGRATED",
)
},
);
result.insert(
"hardware.smart".into(),
Observation {
data: Some(false),
..Observation::unavailable(
"linux.smart",
Quality::Unsupported,
"NO_VERIFIED_READ_ONLY_SMART_PROVIDER",
)
},
);
result
}
pub fn operating_system() -> Observation<OperatingSystem> {
let release = read("/etc/os-release", 32 * 1024);
let kernel = read("/proc/sys/kernel/osrelease", 4096);
let hostname = read("/proc/sys/kernel/hostname", 4096);
let uptime = read("/proc/uptime", 4096);
for (quality, completeness, truncated) in [
(release.quality, release.completeness, release.truncated),
(kernel.quality, kernel.completeness, kernel.truncated),
(hostname.quality, hostname.completeness, hostname.truncated),
(uptime.quality, uptime.completeness, uptime.truncated),
] {
if quality != Quality::Valid || completeness != Completeness::Complete {
let mut failed = Observation::unavailable("linux.os", quality, "OS_SOURCE_INCOMPLETE");
failed.truncated = truncated;
return failed;
}
}
let boot = crate::boot_id();
if let (Some(release), Some(kernel), Some(hostname), Some(uptime), Ok(boot_id)) =
(release.data, kernel.data, hostname.data, uptime.data, boot)
{
let Some(uptime_seconds) = uptime
.split_whitespace()
.next()
.and_then(|x| x.parse::<f64>().ok())
.filter(|x| x.is_finite() && *x >= 0.0)
else {
return Observation::unavailable("linux.os", Quality::Error, "INVALID_UPTIME");
};
let release = release
.lines()
.filter(|l| !l.starts_with('#'))
.filter_map(|line| {
line.split_once('=')
.map(|(k, v)| (k.into(), v.trim_matches('"').into()))
})
.collect();
Observation::valid(
"linux.os:/etc/os-release,/proc",
OperatingSystem {
release,
kernel: kernel.trim().into(),
architecture: std::env::consts::ARCH.into(),
hostname: hostname.trim().into(),
boot_id,
uptime_seconds,
},
)
} else {
Observation::unavailable("linux.os", Quality::Error, "OS_SOURCE_UNAVAILABLE")
}
}
pub fn cpu() -> Observation<Cpu> {
let info = read("/proc/cpuinfo", 1024 * 1024);
let stat = read("/proc/stat", 256 * 1024);
for (quality, completeness, truncated) in [
(info.quality, info.completeness, info.truncated),
(stat.quality, stat.completeness, stat.truncated),
] {
if quality != Quality::Valid || completeness != Completeness::Complete {
let mut failed =
Observation::unavailable("linux.cpu", quality, "CPU_SOURCE_INCOMPLETE");
failed.truncated = truncated;
return failed;
}
}
match (info.data, stat.data) {
(Some(info), Some(stat)) => {
let logical_processors = info
.lines()
.filter(|l| {
l.split_once(':')
.is_some_and(|(k, _)| k.trim() == "processor")
})
.count();
let model = info.lines().find_map(|l| {
l.split_once(':')
.filter(|(k, _)| k.trim() == "model name")
.map(|(_, v)| v.trim().to_owned())
});
let aggregate_jiffies: Option<Vec<u64>> =
stat.lines().find(|l| l.starts_with("cpu ")).and_then(|l| {
l.split_whitespace()
.skip(1)
.map(str::parse)
.collect::<Result<Vec<_>, _>>()
.ok()
});
match aggregate_jiffies {
Some(aggregate_jiffies) if logical_processors > 0 => Observation::valid(
"linux.cpu:/proc/cpuinfo,/proc/stat",
Cpu {
logical_processors,
model,
aggregate_jiffies,
},
),
_ => Observation::unavailable("linux.cpu", Quality::Error, "INVALID_CPU_DATA"),
}
}
_ => Observation::unavailable("linux.cpu", Quality::Error, "CPU_SOURCE_UNAVAILABLE"),
}
}
pub fn parse_memory(text: &str) -> Option<Memory> {
let values: BTreeMap<_, _> = text
.lines()
.filter_map(|l| {
let (k, v) = l.split_once(':')?;
let mut fields = v.split_whitespace();
let value = fields.next()?.parse::<u64>().ok()?;
(fields.next()? == "kB").then_some((k, value.checked_mul(1024)?))
})
.collect();
let memory = Memory {
total_bytes: *values.get("MemTotal")?,
available_bytes: values.get("MemAvailable").copied(),
swap_total_bytes: *values.get("SwapTotal")?,
swap_free_bytes: *values.get("SwapFree")?,
};
(memory.total_bytes > 0
&& memory
.available_bytes
.is_none_or(|v| v <= memory.total_bytes)
&& memory.swap_free_bytes <= memory.swap_total_bytes)
.then_some(memory)
}
pub fn memory() -> Observation<Memory> {
let mut observation = map(read("/proc/meminfo", 64 * 1024), |s| parse_memory(&s));
if observation
.data
.as_ref()
.is_some_and(|m| m.available_bytes.is_none())
{
observation = observation.partial("MEM_AVAILABLE_UNKNOWN");
}
observation
}
fn sys_text(path: &str) -> Option<String> {
read(path, 4096).data.map(|s| s.trim().into())
}
fn sys_number(path: &str) -> Option<u64> {
sys_text(path)?.parse().ok()
}
pub fn interfaces() -> Observation<Vec<Interface>> {
let mut head = std::ptr::null_mut();
// SAFETY: head is writable storage for the libc-owned linked list.
if unsafe { libc::getifaddrs(&mut head) } != 0 {
return interface_observation(Err(std::io::Error::last_os_error()));
}
struct Addresses(*mut libc::ifaddrs);
impl Drop for Addresses {
fn drop(&mut self) {
unsafe {
libc::freeifaddrs(self.0);
}
}
}
let _guard = Addresses(head);
let mut entries: BTreeMap<String, Vec<String>> = BTreeMap::new();
let mut current = head;
while !current.is_null() {
// SAFETY: pointers come from the live getifaddrs list; family determines
// sockaddr layout, addresses are copied before freeifaddrs.
unsafe {
let item = &*current;
let name = CStr::from_ptr(item.ifa_name).to_string_lossy().into_owned();
let addresses = entries.entry(name).or_default();
if !item.ifa_addr.is_null() {
match i32::from((*item.ifa_addr).sa_family) {
libc::AF_INET => {
let addr = &*item.ifa_addr.cast::<libc::sockaddr_in>();
addresses
.push(Ipv4Addr::from(addr.sin_addr.s_addr.to_ne_bytes()).to_string());
}
libc::AF_INET6 => {
let addr = &*item.ifa_addr.cast::<libc::sockaddr_in6>();
addresses.push(format!(
"{}%{}",
Ipv6Addr::from(addr.sin6_addr.s6_addr),
addr.sin6_scope_id
));
}
_ => {}
}
}
current = item.ifa_next;
}
}
let data = entries
.into_iter()
.map(|(name, mut addresses)| {
addresses.sort();
addresses.dedup();
let base = format!("/sys/class/net/{name}");
Interface {
mac: sys_text(&format!("{base}/address")),
operstate: sys_text(&format!("{base}/operstate")),
rx_bytes: sys_number(&format!("{base}/statistics/rx_bytes")),
tx_bytes: sys_number(&format!("{base}/statistics/tx_bytes")),
mtu: sys_number(&format!("{base}/mtu")),
name,
addresses,
}
})
.collect::<Vec<_>>();
interface_observation(Ok(data))
}
fn interface_observation(data: std::io::Result<Vec<Interface>>) -> Observation<Vec<Interface>> {
let data = match data {
Ok(data) => data,
Err(error) => {
return Observation::unavailable(
"linux.network:getifaddrs",
if error.kind() == std::io::ErrorKind::PermissionDenied {
Quality::PermissionDenied
} else {
Quality::Error
},
"GETIFADDRS_FAILED",
);
}
};
// An interface may legitimately have no IP address. Completeness depends
// on provider success and readable fields, not on address assignment.
let incomplete = data.iter().any(|i| {
i.mac.is_none()
|| i.operstate.is_none()
|| i.rx_bytes.is_none()
|| i.tx_bytes.is_none()
|| i.mtu.is_none()
});
let result = Observation::valid("linux.network:getifaddrs,/sys/class/net", data);
if incomplete {
result.partial("INTERFACE_FIELDS_UNAVAILABLE")
} else {
result
}
}
#[cfg(test)]
mod interface_regressions {
use super::*;
#[test]
fn addressless_interface_is_complete_but_provider_failure_is_not() {
let interface = Interface {
name: "unconfigured0".into(),
addresses: vec![],
mac: Some("02:00:00:00:00:01".into()),
operstate: Some("down".into()),
rx_bytes: Some(0),
tx_bytes: Some(0),
mtu: Some(1500),
};
let observation = interface_observation(Ok(vec![interface.clone()]));
assert_eq!(observation.quality, Quality::Valid);
assert_eq!(observation.completeness, Completeness::Complete);
let failed = interface_observation(Err(std::io::Error::from_raw_os_error(libc::EIO)));
assert_eq!(failed.quality, Quality::Error);
assert_eq!(failed.completeness, Completeness::Unknown);
assert!(failed.data.is_none());
let denied = interface_observation(Err(std::io::Error::from_raw_os_error(libc::EACCES)));
assert_eq!(denied.quality, Quality::PermissionDenied);
let missing_field = Interface {
mtu: None,
..interface
};
assert_eq!(
interface_observation(Ok(vec![missing_field])).completeness,
Completeness::Partial
);
}
}
pub fn routes() -> Observation<Vec<Route>> {
let v4 = read("/proc/net/route", 256 * 1024);
let v6 = read("/proc/net/ipv6_route", 256 * 1024);
let mut failed = v4.data.is_none() || v6.data.is_none() || v4.truncated || v6.truncated;
let mut routes = vec![];
if let Some(text) = v4.data {
for line in text.lines().skip(1) {
let fields: Vec<_> = line.split_whitespace().collect();
let parsed = (|| {
if fields.len() < 8 {
return None;
}
let ip = |x: &str| {
u32::from_str_radix(x, 16)
.ok()
.map(|n| Ipv4Addr::from(n.to_le_bytes()).to_string())
};
Some(Route {
interface: fields[0].into(),
destination: ip(fields[1])?,
gateway: ip(fields[2])?,
mask_or_prefix: ip(fields[7])?,
flags: u32::from_str_radix(fields[3], 16).ok()?,
metric: fields[6].parse().ok()?,
})
})();
match parsed {
Some(route) => routes.push(route),
None => failed = true,
}
}
}
if let Some(text) = v6.data {
for line in text.lines() {
let f: Vec<_> = line.split_whitespace().collect();
let parsed = (|| {
if f.len() < 10 {
return None;
}
let ip = |x: &str| {
u128::from_str_radix(x, 16)
.ok()
.map(|n| Ipv6Addr::from(n).to_string())
};
Some(Route {
interface: f[9].into(),
destination: ip(f[0])?,
gateway: ip(f[4])?,
mask_or_prefix: u8::from_str_radix(f[1], 16).ok()?.to_string(),
flags: u32::from_str_radix(f[8], 16).ok()?,
metric: u32::from_str_radix(f[5], 16).ok()?,
})
})();
match parsed {
Some(route) => routes.push(route),
None => failed = true,
}
}
}
let result = Observation::valid("linux.routes:/proc/net/route,/proc/net/ipv6_route", routes);
if failed {
result.partial("ROUTES_INCOMPLETE")
} else {
result
}
}
pub fn dns() -> Observation<Dns> {
map(read("/etc/resolv.conf", 64 * 1024), |text| {
let mut nameservers = vec![];
let mut search = vec![];
for line in text.lines() {
let fields: Vec<_> = line
.split(['#', ';'])
.next()
.unwrap_or("")
.split_whitespace()
.collect();
match fields.first().copied() {
Some("nameserver") => {
nameservers.extend(fields.iter().skip(1).map(|x| (*x).to_owned()))
}
Some("search" | "domain") => {
search.extend(fields.iter().skip(1).map(|x| (*x).to_owned()))
}
_ => {}
}
}
Some(Dns {
nameservers,
search,
resolver_symlink: fs::read_link("/etc/resolv.conf")
.ok()
.map(|p| p.to_string_lossy().into_owned()),
})
})
}
fn mount_unescape(value: &str) -> Option<String> {
let mut result = vec![];
let bytes = value.as_bytes();
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'\\' {
let octal = bytes.get(i + 1..i + 4)?;
if !octal.iter().all(|b| (b'0'..=b'7').contains(b)) {
return None;
}
let value = (octal[0] - b'0') as u16 * 64
+ (octal[1] - b'0') as u16 * 8
+ (octal[2] - b'0') as u16;
result.push(u8::try_from(value).ok()?);
i += 4;
} else {
result.push(bytes[i]);
i += 1;
}
}
String::from_utf8(result).ok()
}
pub fn volumes() -> Observation<Vec<Observation<Volume>>> {
let mut raw = read("/proc/self/mountinfo", 512 * 1024);
if raw
.data
.as_ref()
.is_some_and(|text| text.lines().count() > 4096)
{
raw = raw.partial("MOUNT_COUNT_LIMIT");
raw.truncated = true;
}
map(raw, |text| {
let mut observations = vec![];
for line in text.lines().take(4096) {
let Some((left, right)) = line.split_once(" - ") else {
observations.push(Observation::unavailable(
"linux.mountinfo",
Quality::Error,
"INVALID_MOUNT",
));
continue;
};
let left: Vec<_> = left.split_whitespace().collect();
let right: Vec<_> = right.split_whitespace().collect();
if left.len() < 5 || right.len() < 2 {
observations.push(Observation::unavailable(
"linux.mountinfo",
Quality::Error,
"INVALID_MOUNT",
));
continue;
}
let Some(mount) = mount_unescape(left[4]) else {
observations.push(Observation::unavailable(
"linux.mountinfo",
Quality::Error,
"INVALID_MOUNT_ENCODING",
));
continue;
};
observations.push(volume(&mount, right[0], right[1]));
}
Some(observations)
})
.with_volume_completeness()
}
impl Observation<Vec<Observation<Volume>>> {
fn with_volume_completeness(mut self) -> Self {
if self
.data
.as_ref()
.is_some_and(|v| v.iter().any(|x| x.quality != Quality::Valid))
{
self = self.partial("VOLUME_ERRORS");
}
self
}
}
fn volume(mount: &str, filesystem: &str, device: &str) -> Observation<Volume> {
// Remote filesystems can hang statvfs indefinitely; explicitly do not probe.
const LOCAL: &[&str] = &[
"ext2", "ext3", "ext4", "xfs", "btrfs", "tmpfs", "overlay", "vfat", "exfat", "f2fs", "zfs",
"squashfs", "ramfs", "devtmpfs",
];
let source = format!("linux.statvfs:{mount}");
if !LOCAL.contains(&filesystem) {
return Observation::unavailable(
&source,
Quality::Unsupported,
"FILESYSTEM_NOT_SAFE_FOR_INLINE_STATVFS",
);
}
let Ok(path) = CString::new(mount) else {
return Observation::unavailable(&source, Quality::Error, "INVALID_MOUNT_PATH");
};
let mut stat = MaybeUninit::<libc::statvfs>::uninit();
// SAFETY: path is terminated and stat is aligned writable storage.
if unsafe { libc::statvfs(path.as_ptr(), stat.as_mut_ptr()) } != 0 {
let e = std::io::Error::last_os_error();
return Observation::unavailable(
&source,
if e.kind() == std::io::ErrorKind::PermissionDenied {
Quality::PermissionDenied
} else {
Quality::Error
},
"STATVFS_FAILED",
);
}
let stat = unsafe { stat.assume_init() };
let Some(total_bytes) = stat.f_blocks.checked_mul(stat.f_frsize) else {
return Observation::unavailable(&source, Quality::Error, "VOLUME_OVERFLOW");
};
let Some(free_bytes) = stat.f_bfree.checked_mul(stat.f_frsize) else {
return Observation::unavailable(&source, Quality::Error, "VOLUME_OVERFLOW");
};
let Some(available_bytes) = stat.f_bavail.checked_mul(stat.f_frsize) else {
return Observation::unavailable(&source, Quality::Error, "VOLUME_OVERFLOW");
};
Observation::valid(
&source,
Volume {
mount_point: mount.into(),
filesystem: filesystem.into(),
device: mount_unescape(device).unwrap_or_else(|| device.into()),
total_bytes,
free_bytes,
available_bytes,
available_percent: (total_bytes > 0)
.then(|| available_bytes as f64 * 100.0 / total_bytes as f64),
total_inodes: stat.f_files,
free_inodes: stat.f_ffree,
available_inodes: stat.f_favail,
available_inode_percent: (stat.f_files > 0)
.then(|| stat.f_favail as f64 * 100.0 / stat.f_files as f64),
},
)
}
fn journal_permission_failure(stderr: &[u8]) -> bool {
let s = String::from_utf8_lossy(stderr).to_ascii_lowercase();
s.contains("permission denied")
|| s.contains("access denied")
|| s.contains("insufficient permissions")
|| s.contains("not seeing messages from other users")
}
fn command(program: &str, args: &[&str], cap: usize) -> Observation<String> {
let started = SystemTime::now();
match process::run(
program,
&args.iter().map(|s| (*s).into()).collect::<Vec<_>>(),
Duration::from_secs(15),
cap,
) {
Ok(output) => {
if output.timed_out {
return Observation::unavailable(program, Quality::Unknown, "PROVIDER_TIMEOUT");
}
if program == "/usr/bin/journalctl" && journal_permission_failure(&output.stderr) {
return Observation::unavailable(
"linux.journald",
Quality::PermissionDenied,
"JOURNAL_ACCESS_DENIED_OR_FILTERED",
);
}
if output.code != Some(0) {
let stderr = String::from_utf8_lossy(&output.stderr);
let quality =
if stderr.contains("Permission denied") || stderr.contains("Access denied") {
Quality::PermissionDenied
} else {
Quality::Error
};
return Observation::unavailable(program, quality, "PROVIDER_EXIT_FAILURE");
}
match String::from_utf8(output.stdout) {
Ok(text) => {
let mut observation = Observation::valid(program, text);
observation.observed_at = started;
if output.truncated {
observation = observation.partial("OUTPUT_LIMIT");
observation.truncated = true;
}
observation
}
Err(_) => Observation::unavailable(program, Quality::Error, "NON_UTF8_OUTPUT"),
}
}
Err(e) => {
let quality = e
.downcast_ref::<std::io::Error>()
.map(|e| match e.kind() {
std::io::ErrorKind::NotFound => Quality::Unsupported,
std::io::ErrorKind::PermissionDenied => Quality::PermissionDenied,
_ => Quality::Error,
})
.unwrap_or(Quality::Error);
Observation::unavailable(program, quality, "PROVIDER_UNAVAILABLE")
}
}
}
pub fn software() -> Observation<Vec<SoftwarePackage>> {
let raw = command(
"/usr/bin/dpkg-query",
&[
"--show",
"--showformat=${Package}\t${Version}\t${Architecture}\t${db:Status-Status}\\n",
],
512 * 1024,
);
let mut parse_failure = false;
let mut result = map(raw, |text| {
let packages = text
.lines()
.filter_map(|line| {
let f: Vec<_> = line.split('\t').collect();
if f.len() != 4 {
parse_failure = true;
return None;
}
(f[3] == "installed").then(|| SoftwarePackage {
name: f[0].into(),
version: f[1].into(),
architecture: f[2].into(),
status: f[3].into(),
})
})
.collect();
Some(packages)
});
if parse_failure {
result = result.partial("DPKG_PARSE_PARTIAL");
}
result
}
pub fn service_status(unit: &ServiceUnit) -> Observation<ServiceStatus> {
if !Path::new("/run/systemd/system").is_dir() {
return Observation::unavailable(
"linux.systemd",
Quality::Unsupported,
"SYSTEMD_NOT_RUNNING",
);
}
let raw = command(
"/usr/bin/systemctl",
&[
"show",
"--no-pager",
"--property=Id,LoadState,ActiveState,SubState,UnitFileState",
"--",
unit.as_str(),
],
32 * 1024,
);
map(raw, |text| {
let f: BTreeMap<_, _> = text.lines().filter_map(|l| l.split_once('=')).collect();
Some(ServiceStatus {
unit: unit.clone(),
id: f.get("Id")?.to_string(),
load_state: f.get("LoadState")?.to_string(),
active_state: f.get("ActiveState")?.to_string(),
sub_state: f.get("SubState")?.to_string(),
unit_file_state: f.get("UnitFileState")?.to_string(),
})
})
}
pub fn check_services(expectations: &[ServiceExpectation]) -> anyhow::Result<Vec<ServiceCheck>> {
anyhow::ensure!(
expectations.len() <= 128,
"too many service expectations; maximum 128"
);
Ok(check_services_inner(expectations))
}
fn check_services_inner(expectations: &[ServiceExpectation]) -> Vec<ServiceCheck> {
expectations
.iter()
.take(128)
.map(|expectation| {
let status = service_status(&expectation.unit);
let matches = status
.data
.as_ref()
.filter(|s| s.id == expectation.unit.as_str() && s.load_state == "loaded")
.map(|s| {
if expectation.expected_active {
s.active_state == "active"
} else {
s.active_state == "inactive"
}
});
ServiceCheck {
expectation: expectation.clone(),
status,
matches,
}
})
.collect()
}
pub fn updates() -> Observation<UpdateStatus> {
// Both commands read existing metadata only; never `apt update`. APT's list
// output is not a stable API, so parsing is checked and marked partial.
let policy = command("/usr/bin/apt-cache", &["policy"], 64 * 1024);
if policy.data.is_none() {
return Observation::unavailable(
"linux.apt-local",
policy.quality,
"APT_CACHE_UNAVAILABLE",
);
}
let raw = command("/usr/bin/apt", &["list", "--upgradable"], 256 * 1024);
let mut parse_failure = false;
let mut result = map(raw, |text| {
let mut available = vec![];
for line in text
.lines()
.filter(|l| !l.is_empty() && !l.starts_with("Listing"))
{
let fields: Vec<_> = line.split_whitespace().collect();
if fields.len() < 3 || !fields[0].contains('/') {
parse_failure = true;
continue;
}
available.push(AvailableUpdate {
package: fields[0].split('/').next().unwrap_or("").into(),
candidate_version: fields[1].into(),
architecture: fields[2].into(),
installed_version: line
.split_once("upgradable from: ")
.and_then(|(_, v)| v.strip_suffix(']'))
.map(str::to_owned),
});
}
let newest_local_metadata_at = fs::read_dir("/var/lib/apt/lists")
.ok()
.into_iter()
.flatten()
.filter_map(Result::ok)
.filter_map(|entry| {
let name = entry.file_name();
let name = name.to_string_lossy();
if name.ends_with("_InRelease")
|| name.ends_with("_Release")
|| name.contains("_Packages")
{
entry.metadata().ok()?.modified().ok()
} else {
None
}
})
.max();
Some(UpdateStatus {
available,
newest_local_metadata_at,
last_successful_scan_at: None,
metadata_fresh: None,
reboot_required: reboot_required(),
history_quality: Quality::Unknown,
})
});
result.source_id = "linux.apt-local:apt-cache-policy,apt-list,/var/lib/apt/lists".into();
if result.data.is_some() {
result = result.partial(if parse_failure {
"APT_PARSE_PARTIAL"
} else {
"METADATA_FRESHNESS_AND_HISTORY_UNKNOWN"
});
}
result
}
pub fn hardware() -> Observation<Hardware> {
let mut readable_dmi = BTreeMap::new();
for field in [
"sys_vendor",
"product_name",
"product_version",
"board_vendor",
"board_name",
"bios_vendor",
"bios_version",
"bios_date",
] {
if let Some(value) = sys_text(&format!("/sys/class/dmi/id/{field}")) {
readable_dmi.insert(field.into(), value);
}
}
if readable_dmi.is_empty() {
Observation::unavailable(
"linux.dmi:/sys/class/dmi/id",
Quality::Unsupported,
"DMI_UNAVAILABLE",
)
} else {
Observation::valid("linux.dmi:/sys/class/dmi/id", Hardware { readable_dmi })
.partial("READABLE_DMI_ONLY_NO_SMART_OR_ENCRYPTION_PROOF")
}
}
#[derive(Debug, Clone)]
pub struct JournalRequest {
unit: ServiceUnit,
since_epoch: u64,
until_epoch: u64,
max_lines: usize,
max_bytes: usize,
since_filter: String,
until_filter: String,
}
impl JournalRequest {
pub fn new(
unit: ServiceUnit,
allowed_units: &[ServiceUnit],
since_epoch: u64,
until_epoch: u64,
max_lines: usize,
max_bytes: usize,
) -> anyhow::Result<Self> {
anyhow::ensure!(allowed_units.contains(&unit), "log unit not allowlisted");
anyhow::ensure!(
until_epoch >= since_epoch
&& until_epoch - since_epoch <= 86400
&& until_epoch <= i64::MAX as u64,
"invalid log window (maximum 24h)"
);
anyhow::ensure!(
(1..=1000).contains(&max_lines) && (1..=256 * 1024).contains(&max_bytes),
"invalid log limits"
);
Ok(Self {
unit,
since_epoch,
until_epoch,
max_lines,
max_bytes,
since_filter: format!("@{since_epoch}"),
until_filter: format!("@{until_epoch}"),
})
}
/// Journald timestamps are microseconds. Round inward, never widen the
/// signed RFC3339 interval by flooring a fractional start to whole seconds.
pub fn precise_window(
mut self,
since: chrono::DateTime<chrono::Utc>,
until: chrono::DateTime<chrono::Utc>,
) -> anyhow::Result<Self> {
anyhow::ensure!(
u64::try_from(since.timestamp())? == self.since_epoch
&& u64::try_from(until.timestamp())? == self.until_epoch,
"LOG_WINDOW_BINDING"
);
let start = since
.timestamp_micros()
.checked_add(i64::from(
!since.timestamp_subsec_nanos().is_multiple_of(1000),
))
.ok_or_else(|| anyhow::anyhow!("LOG_TIMESTAMP_OVERFLOW"))?;
let end = until.timestamp_micros();
anyhow::ensure!(start <= end, "LOG_WINDOW_BELOW_NATIVE_PRECISION");
self.since_filter = format!("@{}.{:06}", start / 1_000_000, start % 1_000_000);
self.until_filter = format!("@{}.{:06}", end / 1_000_000, end % 1_000_000);
Ok(self)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct JournalExcerpt {
pub unit: ServiceUnit,
pub since_epoch: u64,
pub until_epoch: u64,
pub since_filter: String,
pub until_filter: String,
pub json_lines: Vec<String>,
pub next_cursor: Option<String>,
}
/// This is live diagnosis, NOT called by collect_native(). The helper must
/// require the same current plan-bound authorization as all other live jobs.
pub fn query_journal(request: &JournalRequest) -> Observation<JournalExcerpt> {
if !Path::new("/run/systemd/journal").is_dir() && !Path::new("/var/log/journal").is_dir() {
return Observation::unavailable(
"linux.journald",
Quality::Unsupported,
"JOURNAL_UNAVAILABLE",
);
}
let since = &request.since_filter;
let until = &request.until_filter;
// Ask for one extra line to detect the line cap; bounded subprocess output
// also enforces a combined stdout+stderr byte cap.
let count = (request.max_lines + 1).to_string();
let raw = command(
"/usr/bin/journalctl",
&[
"--no-pager",
"--quiet",
"--output=json",
"--unit",
request.unit.as_str(),
"--since",
since.as_str(),
"--until",
until.as_str(),
"--lines",
&count,
],
request.max_bytes,
);
let mut line_truncated = false;
let mut parse_failure = false;
let mut result = map(raw, |text| {
let mut lines: Vec<_> = text
.lines()
.filter_map(
|line| match serde_json::from_str::<serde_json::Value>(line) {
Ok(value) if value.is_object() => Some(line.to_owned()),
_ => {
parse_failure = true;
None
}
},
)
.collect();
// journalctl -n returns the newest lines. Do not invent a durable cursor
// without a JSON parser and server acknowledgement integration.
line_truncated = lines.len() > request.max_lines;
if line_truncated {
lines.remove(0);
}
Some(JournalExcerpt {
unit: request.unit.clone(),
since_epoch: request.since_epoch,
until_epoch: request.until_epoch,
since_filter: request.since_filter.clone(),
until_filter: request.until_filter.clone(),
json_lines: lines,
next_cursor: None,
})
});
if line_truncated {
result = result.partial("LOG_LINE_LIMIT");
result.truncated = true;
}
if parse_failure {
result = result.partial("JOURNAL_JSON_INVALID_OR_TRUNCATED");
result.truncated = true;
if result
.data
.as_ref()
.is_none_or(|excerpt| excerpt.json_lines.is_empty())
{
result.quality = Quality::Error;
result.completeness = Completeness::Unknown;
result.data = None;
}
}
// A readable empty journal is not proof of complete coverage/permissions.
if result.data.is_some() && !parse_failure && !line_truncated {
result = result.partial("JOURNAL_ACCESS_COVERAGE_AND_CURSOR_UNVERIFIED");
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn memory_units_and_mount_escapes() {
let memory = parse_memory(
"MemTotal: 100 kB\nMemAvailable: 25 kB\nSwapTotal: 10 kB\nSwapFree: 3 kB\n",
)
.unwrap();
assert_eq!(memory.total_bytes, 102400);
assert_eq!(memory.available_bytes, Some(25600));
assert_eq!(memory.swap_free_bytes, 3072);
assert!(parse_memory("MemTotal: 18446744073709551615 kB").is_none());
assert_eq!(mount_unescape("/a\\040b\\134c").as_deref(), Some("/a b\\c"));
assert!(mount_unescape("/a\\999").is_none());
}
#[test]
fn journal_limits_and_allowlist() {
assert!(journal_permission_failure(
b"Hint: You are currently not seeing messages from other users and the system."
));
assert!(journal_permission_failure(
b"No journal files were opened due to insufficient permissions."
));
assert!(!journal_permission_failure(b"-- No entries --"));
let unit = ServiceUnit::new("demo.service").unwrap();
assert!(JournalRequest::new(unit.clone(), &[], 0, 60, 10, 100).is_err());
assert!(
JournalRequest::new(unit.clone(), std::slice::from_ref(&unit), 60, 0, 10, 100).is_err()
);
assert!(
JournalRequest::new(unit.clone(), std::slice::from_ref(&unit), 0, 60, 1001, 100)
.is_err()
);
assert!(JournalRequest::new(unit.clone(), &[unit], 0, 60, 10, 100).is_ok());
}
#[test]
fn journal_fractional_window_is_rounded_inward_not_widened() {
let unit = ServiceUnit::new("demo.service").unwrap();
let request = JournalRequest::new(
unit.clone(),
std::slice::from_ref(&unit),
100,
101,
10,
1024,
)
.unwrap()
.precise_window(
chrono::DateTime::from_timestamp(100, 123_456_789).unwrap(),
chrono::DateTime::from_timestamp(101, 987_654_999).unwrap(),
)
.unwrap();
assert_eq!(request.since_filter, "@100.123457");
assert_eq!(request.until_filter, "@101.987654");
}
#[test]
fn harmless_native_read_providers() {
assert_eq!(memory().quality, Quality::Valid);
assert_eq!(cpu().quality, Quality::Valid);
assert_eq!(operating_system().quality, Quality::Valid);
let interfaces = interfaces();
assert!(interfaces.data.is_some());
let volumes = volumes();
assert!(volumes.data.as_ref().is_some_and(|v| {
v.iter()
.any(|x| x.data.as_ref().is_some_and(|v| v.mount_point == "/"))
}));
let software = software();
assert!(matches!(
software.quality,
Quality::Valid | Quality::Unsupported
));
let status = service_status(&ServiceUnit::new("nonexistent-rmm-test.service").unwrap());
if !Path::new("/run/systemd/system").is_dir() {
assert_eq!(status.quality, Quality::Unsupported);
}
assert_eq!(hardware().completeness, Completeness::Partial);
let update_status = updates();
assert!(matches!(
update_status.quality,
Quality::Valid | Quality::Unsupported
));
if let Some(data) = update_status.data {
assert_eq!(data.metadata_fresh, None);
assert_eq!(data.last_successful_scan_at, None);
}
}
}