use std::ffi::OsStr;
use std::ffi::OsString;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use std::path::PathBuf;
fn number(name: &[u8]) -> Option<i32> {
if name.first() == Some(&b'0') || !name.iter().all(u8::is_ascii_digit) {
return None;
}
std::str::from_utf8(name).ok()?.parse().ok()
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum At {
Root,
Proc,
Process {
init: bool,
},
Tasks {
init: bool,
},
Thread,
Links,
Opaque,
Elsewhere {
resolved: bool,
},
Other,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Named {
position: usize,
id: i32,
init_thread: bool,
}
pub(crate) fn components(path: &Path) -> Vec<OsString> {
path.as_os_str()
.as_bytes()
.split(|byte| *byte == b'/')
.filter(|name| !name.is_empty())
.map(|name| OsString::from(OsStr::from_bytes(name)))
.collect()
}
struct Walk {
named: Vec<Named>,
unresolved: Option<usize>,
init: bool,
}
fn walk(path: &Path, resolved: usize) -> Walk {
let mut named = Vec::new();
let mut stack = vec![At::Root];
if !path.is_absolute() {
return Walk {
named,
unresolved: None,
init: false,
};
}
let names = components(path);
let last_number = names
.iter()
.rposition(|name| number(name.as_bytes()).is_some());
for (position, name) in names.iter().enumerate() {
let top = *stack.last().expect("the walk starts at the root");
let name = name.as_bytes();
let unresolved = matches!(top, At::Opaque | At::Elsewhere { resolved: false })
&& (number(name).is_some()
|| (name == b".." && last_number.is_some_and(|last| last > position)));
if unresolved {
return Walk {
named,
unresolved: Some(position),
init: false,
};
}
match name {
b"." => continue,
b".." => {
if stack.len() > 1 {
stack.pop();
}
continue;
}
_ => {}
}
let elsewhere = At::Elsewhere {
resolved: position < resolved,
};
match top {
At::Root if name == b"proc" => stack.push(At::Proc),
At::Root | At::Elsewhere { .. } => stack.push(elsewhere),
At::Proc => match name {
b"self" => stack.push(At::Process { init: false }),
b"thread-self" => stack.extend([
At::Process { init: false },
At::Tasks { init: false },
At::Thread,
]),
b"net" => stack.extend([At::Process { init: false }, At::Other]),
_ => match number(name) {
Some(id) => {
named.push(Named {
position,
id,
init_thread: false,
});
stack.push(At::Process { init: id == 1 });
}
None => stack.push(At::Other),
},
},
At::Process { init } if name == b"task" => stack.push(At::Tasks { init }),
At::Process { .. } | At::Thread => match name {
b"fd" | b"ns" | b"map_files" => stack.push(At::Links),
b"cwd" | b"root" | b"exe" => stack.push(At::Opaque),
_ => stack.push(At::Other),
},
At::Tasks { init } => match number(name) {
Some(id) => {
named.push(Named {
position,
id,
init_thread: init,
});
stack.push(At::Thread);
}
None => stack.push(At::Other),
},
At::Links | At::Opaque => stack.push(At::Opaque),
At::Other => stack.push(At::Other),
}
}
Walk {
named,
unresolved: None,
init: stack.contains(&At::Process { init: true }),
}
}
pub(crate) fn named_ids(path: &Path) -> Vec<i32> {
walk(path, 0)
.named
.into_iter()
.filter(|named| !named.init_thread)
.map(|named| named.id)
.collect()
}
fn rebuilt(names: Vec<OsString>, absolute: bool, like: &Path, trailing: bool) -> PathBuf {
let mut rebuilt = if absolute {
PathBuf::from("/")
} else {
PathBuf::new()
};
rebuilt.extend(names);
if trailing && like.as_os_str().as_bytes().ends_with(b"/") {
rebuilt.as_mut_os_string().push("/");
}
rebuilt
}
pub(crate) fn rebuilt_like(names: Vec<OsString>, like: &Path) -> PathBuf {
rebuilt(names, like.is_absolute(), like, true)
}
pub(crate) struct Lookup<'a> {
rest: &'a Path,
first: usize,
walk: Walk,
}
impl<'a> Lookup<'a> {
pub(crate) fn new(base: Option<&Path>, rest: &'a Path) -> Self {
let base = base.filter(|_| !rest.is_absolute());
let (first, walk) = match base {
None => (0, walk(rest, 0)),
Some(base) => {
let first = components(base).len();
(first, walk(&base.join(rest), first))
}
};
Lookup { rest, first, walk }
}
pub(crate) fn ids(&self) -> Vec<i32> {
self.translatable().map(|named| named.id).collect()
}
fn translatable(&self) -> impl Iterator<Item = &Named> {
self.walk
.named
.iter()
.filter(|named| named.position >= self.first && !named.init_thread)
}
pub(crate) fn translations(&self, map: impl Fn(i32) -> Option<i32>) -> Vec<(usize, OsString)> {
self.translatable()
.filter_map(|named| {
let translated = map(named.id).unwrap_or(0);
(translated != named.id).then(|| {
(
named.position - self.first,
OsString::from(translated.to_string()),
)
})
})
.collect()
}
pub(crate) fn respelled(&self, map: impl Fn(i32) -> Option<i32>) -> PathBuf {
let mut names = components(self.rest);
for (position, name) in self.translations(map) {
names[position] = name;
}
rebuilt_like(names, self.rest)
}
pub(crate) fn stop(&self) -> Option<usize> {
Some(self.walk.unresolved? - self.first)
}
}
pub(crate) fn translate(path: &Path, map: impl Fn(i32) -> Option<i32>) -> Option<PathBuf> {
let lookup = Lookup::new(None, path);
let respelled = lookup.respelled(&map);
(!lookup.translations(map).is_empty()).then_some(respelled)
}
pub(crate) fn names_init(path: &Path) -> bool {
walk(path, 0).init
}
pub(crate) fn names_an_id(directory: &Path, name: &OsStr) -> bool {
!Lookup::new(Some(directory), Path::new(name))
.ids()
.is_empty()
}
#[cfg(test)]
mod tests {
use super::*;
fn kernel(id: i32) -> Option<i32> {
match id {
1 => Some(1),
3 => Some(4),
5 => Some(9),
_ => None,
}
}
#[test]
fn named_ids_are_the_process_and_its_task() {
assert_eq!(named_ids(Path::new("/proc/3/stat")), [3]);
assert_eq!(named_ids(Path::new("/proc/3/task/5/stat")), [3, 5]);
assert_eq!(named_ids(Path::new("/proc/self/task/5")), [5]);
assert!(named_ids(Path::new("/proc/thread-self/task/5")).is_empty());
assert!(named_ids(Path::new("/proc/self/stat")).is_empty());
assert!(named_ids(Path::new("/proc/sys/kernel/pid_max")).is_empty());
assert!(named_ids(Path::new("/proc/03/stat")).is_empty());
assert!(named_ids(Path::new("/tmp/3")).is_empty());
assert!(named_ids(Path::new("proc/3")).is_empty());
assert!(named_ids(Path::new("/proc/3/fd/5")).len() == 1);
}
#[test]
fn translation_rewrites_only_the_numbers() {
assert_eq!(
translate(Path::new("/proc/3/stat"), kernel),
Some(PathBuf::from("/proc/4/stat"))
);
assert_eq!(
translate(Path::new("/proc/3/task/5/comm"), kernel),
Some(PathBuf::from("/proc/4/task/9/comm"))
);
assert_eq!(
translate(Path::new("/proc/self/task/5"), kernel),
Some(PathBuf::from("/proc/self/task/9"))
);
assert_eq!(
translate(Path::new("/proc/3/"), kernel),
Some(PathBuf::from("/proc/4/"))
);
assert_eq!(
translate(Path::new("/proc/3/fd/5"), kernel),
Some(PathBuf::from("/proc/4/fd/5"))
);
assert_eq!(translate(Path::new("/proc/1/stat"), kernel), None);
assert_eq!(translate(Path::new("/proc/1/task/2/ns/pid"), kernel), None);
assert_eq!(translate(Path::new("/proc/self/stat"), kernel), None);
assert_eq!(translate(Path::new("/proc/uptime"), kernel), None);
assert_eq!(translate(Path::new("/etc/3"), kernel), None);
}
#[test]
fn a_number_with_no_counterpart_names_no_process() {
assert_eq!(
translate(Path::new("/proc/7/stat"), kernel),
Some(PathBuf::from("/proc/0/stat"))
);
assert_eq!(
translate(Path::new("/proc/3/task/8"), kernel),
Some(PathBuf::from("/proc/4/task/0"))
);
}
fn relative(base: &str, rest: &str) -> Option<PathBuf> {
let lookup = Lookup::new(Some(Path::new(base)), Path::new(rest));
(!lookup.translations(kernel).is_empty()).then(|| lookup.respelled(kernel))
}
fn unresolved(base: Option<&str>, rest: &str) -> Option<(PathBuf, PathBuf)> {
let lookup = Lookup::new(base.map(Path::new), Path::new(rest));
let at = lookup.stop()?;
let names = components(&lookup.respelled(kernel));
let directory = rebuilt(
names[..at].to_vec(),
rest.starts_with('/'),
Path::new(rest),
false,
);
let directory = match base {
Some(base) => Path::new(base).join(directory),
None => directory,
};
Some((
directory,
rebuilt(names[at..].to_vec(), false, Path::new(rest), true),
))
}
fn pair(directory: &str, rest: &str) -> Option<(PathBuf, PathBuf)> {
Some((PathBuf::from(directory), PathBuf::from(rest)))
}
#[test]
fn dot_dot_goes_back_where_a_lookup_goes() {
assert_eq!(named_ids(Path::new("/proc/3/../5/stat")), [3, 5]);
assert_eq!(
translate(Path::new("/proc/3/../5/stat"), kernel),
Some(PathBuf::from("/proc/4/../9/stat"))
);
assert_eq!(
translate(Path::new("/proc/self/../3/stat"), kernel),
Some(PathBuf::from("/proc/self/../4/stat"))
);
assert_eq!(
translate(Path::new("/proc/thread-self/../5"), kernel),
Some(PathBuf::from("/proc/thread-self/../9"))
);
assert_eq!(
translate(Path::new("/proc/net/../../3/exe"), kernel),
Some(PathBuf::from("/proc/net/../../4/exe"))
);
let bytes = |path: Option<PathBuf>| path.map(|path| path.into_os_string());
assert_eq!(
bytes(translate(Path::new("/proc/3/."), kernel)),
Some("/proc/4/.".into())
);
assert_eq!(
bytes(translate(Path::new("/proc/3/stat/."), kernel)),
Some("/proc/4/stat/.".into())
);
assert_eq!(
bytes(translate(Path::new("/proc/3/./cwd/."), kernel)),
Some("/proc/4/./cwd/.".into())
);
assert_eq!(
bytes(relative("/proc", "5/stat/.")),
Some("9/stat/.".into())
);
}
#[test]
fn past_a_link_the_walk_stops_where_the_link_decides() {
assert_eq!(named_ids(Path::new("/proc/3/cwd/../5")), [3]);
assert_eq!(
unresolved(None, "/proc/3/cwd/../5"),
pair("/proc/4/cwd", "../5")
);
assert_eq!(named_ids(Path::new("/proc/3/fd/7/../5")), [3]);
assert_eq!(named_ids(Path::new("/proc/3/task/5/cwd/../../6")), [3, 5]);
assert_eq!(
unresolved(None, "/proc/self/fd/4/3/exe"),
pair("/proc/self/fd/4", "3/exe")
);
assert_eq!(unresolved(None, "/proc/3/cwd/file"), None);
assert_eq!(unresolved(None, "/proc/3/cwd/../file"), None);
assert_eq!(unresolved(None, "/usr/lib/../lib64/ld.so"), None);
assert_eq!(
translate(Path::new("/proc/3/fd/7/x"), kernel),
Some("/proc/4/fd/7/x".into())
);
assert_eq!(
unresolved(None, "/tmp/U/link/../../../proc/3/stat"),
pair("/tmp/U/link", "../../../proc/3/stat")
);
assert_eq!(
translate(Path::new("/tmp/U/link/../../../proc/3/stat"), kernel),
None
);
assert_eq!(unresolved(None, "/tmp/link/3"), pair("/tmp/link", "3"));
assert_eq!(
relative("/tmp", "../proc/3/stat"),
Some("../proc/4/stat".into())
);
assert_eq!(unresolved(Some("/tmp"), "../proc/3/stat"), None);
assert_eq!(
unresolved(Some("/tmp/U"), "link/../3"),
pair("/tmp/U/link", "../3")
);
assert_eq!(
unresolved(None, "/usr/lib/x86_64-linux-gnu/libc.so.6"),
None
);
}
#[test]
fn relative_lookups_translate_only_their_own_numbers() {
assert_eq!(
relative("/proc/3/task", "3/stat"),
Some(PathBuf::from("4/stat"))
);
assert_eq!(relative("/proc/3", "task/3"), Some(PathBuf::from("task/4")));
let ids =
|base: &str, rest: &str| Lookup::new(Some(Path::new(base)), Path::new(rest)).ids();
assert_eq!(ids("/proc/3", "task/3"), [3]);
assert_eq!(ids("/proc/3", "stat"), Vec::<i32>::new());
assert_eq!(relative("/proc", "3/stat"), Some(PathBuf::from("4/stat")));
assert_eq!(relative("/proc/3", "task/5"), Some(PathBuf::from("task/9")));
assert_eq!(
relative("/proc/3/task", "5/stat"),
Some(PathBuf::from("9/stat"))
);
assert_eq!(relative("/proc/3", "stat"), None);
assert_eq!(relative("/proc", "uptime"), None);
assert_eq!(relative("/proc", "/proc/3"), Some(PathBuf::from("/proc/4")));
}
#[test]
fn ids_are_the_entries_of_proc_and_of_a_task_directory() {
assert!(names_an_id(Path::new("/proc"), OsStr::new("3")));
assert!(names_an_id(Path::new("/proc/3/task"), OsStr::new("5")));
assert!(!names_an_id(Path::new("/proc"), OsStr::new("self")));
assert!(!names_an_id(Path::new("/proc/3/fd"), OsStr::new("5")));
assert!(!names_an_id(Path::new("/proc"), OsStr::new("03")));
assert!(!names_an_id(Path::new("/proc/1/task"), OsStr::new("2")));
}
#[test]
fn the_init_is_where_the_lookup_ends() {
assert!(names_init(Path::new("/proc/1/task/2/stat")));
assert!(!names_init(Path::new("/proc/3/stat")));
assert!(!names_init(Path::new("/proc/self/stat")));
assert!(!names_init(Path::new("/proc/1/../3/stat")));
assert!(names_init(Path::new("/proc/3/../1/task/2/stat")));
assert_eq!(
translate(Path::new("/proc/3/../1/task/2/stat"), kernel),
Some(PathBuf::from("/proc/4/../1/task/2/stat"))
);
}
}