use std::{
env::{self, VarError},
os::fd::{AsFd, BorrowedFd, FromRawFd, OwnedFd, RawFd},
process,
str::FromStr,
};
use rustix::io::{FdFlags, fcntl_setfd};
use crate::{Error, Result};
#[derive(Debug, Default)]
pub struct Passed {
fds: Vec<(String, OwnedFd)>,
created_with: Vec<String>,
}
impl Passed {
pub unsafe fn from_env() -> Result<Self> {
let pid = var("LISTEN_PID");
let fds = var("LISTEN_FDS");
let names = var("LISTEN_FDNAMES");
for name in [
"LISTEN_PID",
"LISTEN_PIDFDID",
"LISTEN_FDS",
"LISTEN_FDNAMES",
] {
unsafe { env::remove_var(name) };
}
let Some(count) = parse_count(pid?.as_deref(), fds?.as_deref(), process::id())? else {
return Ok(Self::default());
};
let fds = take_fds(count)?;
let names = parse_names(names?.as_deref(), count)?;
Ok(Self::new(names.into_iter().zip(fds).collect()))
}
pub fn new(fds: Vec<(String, OwnedFd)>) -> Self {
let created_with = fds.iter().map(|(name, _)| name.clone()).collect();
Self { fds, created_with }
}
pub fn take(&mut self, name: &str) -> Option<OwnedFd> {
let index = self.fds.iter().position(|(passed, _)| passed == name)?;
Some(self.fds.remove(index).1)
}
pub fn take_all(&mut self, name: &str) -> Vec<OwnedFd> {
self.fds
.extract_if(.., |(passed, _)| passed == name)
.map(|(_, fd)| fd)
.collect()
}
pub fn iter(&self) -> impl ExactSizeIterator<Item = (&str, BorrowedFd<'_>)> {
self.fds
.iter()
.map(|(name, fd)| (name.as_str(), fd.as_fd()))
}
pub fn len(&self) -> usize {
self.fds.len()
}
pub fn is_empty(&self) -> bool {
self.fds.is_empty()
}
pub fn into_vec(self) -> Vec<(String, OwnedFd)> {
self.fds
}
pub(crate) fn had_other_than(&self, prefix: &str) -> bool {
self.created_with
.iter()
.any(|name| !name.starts_with(prefix))
}
pub(crate) fn take_prefixed(&mut self, prefix: &str) -> Vec<(String, OwnedFd)> {
self.fds
.extract_if(.., |(name, _)| name.starts_with(prefix))
.collect()
}
}
fn var(name: &str) -> Result<Option<String>> {
match env::var(name) {
Ok(value) => Ok(Some(value)),
Err(VarError::NotPresent) => Ok(None),
Err(VarError::NotUnicode(_)) => {
Err(Error::Environment(format!("${name} isn't valid Unicode")))
}
}
}
fn parse_count(pid: Option<&str>, fds: Option<&str>, own_pid: u32) -> Result<Option<usize>> {
let Some(pid) = pid else {
return Ok(None);
};
if parse_number::<u32>("$LISTEN_PID", pid)? != own_pid {
return Ok(None);
}
let Some(fds) = fds else {
return Ok(None);
};
match parse_number("$LISTEN_FDS", fds)? {
count @ 1..=MAX_LISTEN_FDS => Ok(Some(count)),
count => Err(Error::Environment(format!(
"$LISTEN_FDS is {count}, not a number from 1 to {MAX_LISTEN_FDS}"
))),
}
}
fn take_fds(count: usize) -> Result<Vec<OwnedFd>> {
(START..)
.take(count)
.map(|fd| -> Result<OwnedFd> {
let borrowed = unsafe { BorrowedFd::borrow_raw(fd) };
fcntl_setfd(borrowed, FdFlags::CLOEXEC).map_err(Error::os)?;
Ok(unsafe { OwnedFd::from_raw_fd(fd) })
})
.collect()
}
fn parse_names(names: Option<&str>, count: usize) -> Result<Vec<String>> {
let Some(names) = names else {
return Ok(vec![UNKNOWN.to_owned(); count]);
};
let names: Vec<_> = names.split(':').map(str::to_owned).collect();
if names.len() != count {
return Err(Error::Environment(format!(
"$LISTEN_FDNAMES has {} names for {count} file descriptors",
names.len()
)));
}
Ok(names)
}
fn parse_number<T>(name: &str, value: &str) -> Result<T>
where
T: FromStr,
T::Err: std::error::Error,
{
value
.parse()
.map_err(|e| Error::Environment(format!("{name} is {value:?}, not a number: {e}")))
}
const MAX_LISTEN_FDS: usize = (RawFd::MAX - START) as usize;
pub(crate) const START: RawFd = 3;
const UNKNOWN: &str = "unknown";
#[cfg(test)]
mod tests {
use std::os::fd::AsRawFd;
use rustix::io::fcntl_getfd;
use super::*;
use crate::test_utils::{in_own_process, is_open, pipe};
#[test]
fn count() {
assert_eq!(parse_count(Some("42"), Some("3"), 42).unwrap(), Some(3));
assert_eq!(parse_count(Some("42"), Some("1"), 42).unwrap(), Some(1));
assert_eq!(
parse_count(Some("42"), Some(&MAX_LISTEN_FDS.to_string()), 42).unwrap(),
Some(MAX_LISTEN_FDS)
);
}
#[test]
fn count_is_none_unless_for_this_process() {
assert_eq!(parse_count(None, Some("3"), 42).unwrap(), None);
assert_eq!(parse_count(Some("42"), None, 42).unwrap(), None);
assert_eq!(parse_count(None, None, 42).unwrap(), None);
assert_eq!(parse_count(Some("41"), Some("3"), 42).unwrap(), None);
assert_eq!(parse_count(Some("43"), Some("3"), 42).unwrap(), None);
assert_eq!(parse_count(Some("41"), Some("garbage"), 42).unwrap(), None);
}
#[test]
fn count_garbage() {
for pid in ["", "x", "-1", " 42", "42 ", "4.2", "4294967296"] {
let error = parse_count(Some(pid), Some("3"), 42).unwrap_err();
assert!(
matches!(error, Error::Environment(_)),
"$LISTEN_PID={pid:?}: {error:?}"
);
}
let too_many = (MAX_LISTEN_FDS + 1).to_string();
for fds in [
"",
"x",
"-1",
"0",
"3 ",
"1.5",
"99999999999999999999",
&too_many,
] {
let error = parse_count(Some("42"), Some(fds), 42).unwrap_err();
assert!(
matches!(error, Error::Environment(_)),
"$LISTEN_FDS={fds:?}: {error:?}"
);
}
}
#[test]
fn names() {
let names = parse_names(Some("web:ssh:stored"), 3).unwrap();
assert_eq!(names, ["web", "ssh", "stored"]);
let names = parse_names(Some("a:a:unknown:"), 4).unwrap();
assert_eq!(names, ["a", "a", "unknown", ""]);
assert_eq!(parse_names(Some(""), 1).unwrap(), [""]);
assert_eq!(parse_names(Some("one"), 1).unwrap(), ["one"]);
}
#[test]
fn names_unknown() {
assert_eq!(
parse_names(None, 3).unwrap(),
["unknown", "unknown", "unknown"]
);
assert_eq!(parse_names(None, 1).unwrap(), ["unknown"]);
}
#[test]
fn names_that_do_not_match_the_count() {
for (names, count) in [("a:b", 3), ("a:b:c", 2), ("a", 2), ("", 2), ("a:b", 1)] {
let error = parse_names(Some(names), count).unwrap_err();
assert!(
matches!(error, Error::Environment(_)),
"{names:?} for {count}: {error:?}"
);
}
}
#[test]
fn take_by_name() {
let fd = || pipe().1;
let mut passed = Passed::new(vec![
("a".to_owned(), fd()),
("b".to_owned(), fd()),
("a".to_owned(), fd()),
("prefix/x".to_owned(), fd()),
("prefix/y".to_owned(), fd()),
]);
let numbers =
|passed: &Passed| -> Vec<_> { passed.iter().map(|(_, fd)| fd.as_raw_fd()).collect() };
let all = numbers(&passed);
assert!(passed.take("c").is_none());
assert_eq!(passed.take("a").unwrap().as_raw_fd(), all[0]);
let prefixed: Vec<_> = passed
.take_prefixed("prefix/")
.into_iter()
.map(|(name, fd)| (name, fd.as_raw_fd()))
.collect();
assert_eq!(
prefixed,
[
("prefix/x".to_owned(), all[3]),
("prefix/y".to_owned(), all[4])
]
);
let names: Vec<_> = passed.iter().map(|(name, _)| name).collect();
assert_eq!(names, ["b", "a"]);
let taken: Vec<_> = passed
.take_all("a")
.iter()
.map(AsRawFd::as_raw_fd)
.collect();
assert_eq!(taken, [all[2]]);
assert_eq!(passed.len(), 1);
assert!(passed.take_all("a").is_empty());
let left = passed.into_vec();
assert_eq!(left[0].0, "b");
assert_eq!(left[0].1.as_raw_fd(), all[1]);
}
#[test]
fn had_other_than_remembers_what_it_was_created_with() {
let fd = || pipe().1;
let passed = |names: &[&str]| {
Passed::new(names.iter().map(|name| (name.to_string(), fd())).collect())
};
assert!(!Passed::default().had_other_than("key/"));
assert!(!passed(&[]).had_other_than("key/"));
assert!(!passed(&["key/state", "key/fds", "key/fds"]).had_other_than("key/"));
assert!(passed(&["key/state", "web"]).had_other_than("key/"));
assert!(passed(&["other/state"]).had_other_than("key/"));
assert!(passed(&["unknown"]).had_other_than("key/"));
assert!(!passed(&["web"]).had_other_than(""));
assert!(!passed(&["web"]).had_other_than("w"));
let mut passed = passed(&["web", "key/state", "web", "key/fds", "ssh"]);
assert!(passed.had_other_than("key/"));
passed.take("web").unwrap();
assert!(passed.had_other_than("key/"));
assert_eq!(passed.take_all("web").len(), 1);
assert!(passed.had_other_than("key/"));
assert_eq!(passed.take_prefixed("key/").len(), 2);
assert!(passed.had_other_than("key/"));
passed.take("ssh").unwrap();
assert!(passed.is_empty());
assert!(passed.had_other_than("key/"));
let left = passed.into_vec();
assert!(left.is_empty());
}
#[test]
fn had_other_than_ignores_what_was_taken_out_when_nothing_else_was_there() {
let mut passed = Passed::new(vec![("key/state".to_owned(), pipe().1)]);
passed.take_prefixed("key/");
assert!(passed.is_empty());
assert!(!passed.had_other_than("key/"));
}
#[test]
fn from_the_environment() {
let exports = "LISTEN_PID=$$ LISTEN_FDS=2 LISTEN_FDNAMES=first:second LISTEN_PIDFDID=1";
if !in_own_process("passed::tests::from_the_environment", exports) {
return;
}
let passed = unsafe { Passed::from_env() }.unwrap();
let names: Vec<_> = passed.iter().map(|(name, _)| name).collect();
assert_eq!(names, ["first", "second"]);
let numbers: Vec<_> = passed.iter().map(|(_, fd)| fd.as_raw_fd()).collect();
assert_eq!(numbers, [3, 4]);
for (_, fd) in passed.iter() {
assert!(fcntl_getfd(fd).unwrap().contains(FdFlags::CLOEXEC));
}
assert_listen_variables_removed();
assert!(unsafe { Passed::from_env() }.unwrap().is_empty());
}
#[test]
fn from_the_environment_of_another_process() {
let exports = "LISTEN_PID=1 LISTEN_FDS=2 LISTEN_FDNAMES=a:b LISTEN_PIDFDID=1";
if !in_own_process(
"passed::tests::from_the_environment_of_another_process",
exports,
) {
return;
}
assert!(unsafe { Passed::from_env() }.unwrap().is_empty());
assert_listen_variables_removed();
assert!(is_open(3) && is_open(4));
}
#[test]
fn from_the_environment_closes_all_on_error() {
let exports = "LISTEN_PID=$$ LISTEN_FDS=2 LISTEN_FDNAMES=a";
if !in_own_process(
"passed::tests::from_the_environment_closes_all_on_error",
exports,
) {
return;
}
let error = unsafe { Passed::from_env() }.unwrap_err();
assert!(matches!(error, Error::Environment(_)), "{error:?}");
assert!(!is_open(3) && !is_open(4));
assert_listen_variables_removed();
}
#[test]
fn from_the_environment_with_fds_that_are_not_open() {
let exports = "LISTEN_PID=$$ LISTEN_FDS=3";
let test = "passed::tests::from_the_environment_with_fds_that_are_not_open";
if !in_own_process(test, exports) {
return;
}
let error = unsafe { Passed::from_env() }.unwrap_err();
let Error::Io(error) = error else {
panic!("{error:?}");
};
assert_eq!(
error.raw_os_error(),
Some(rustix::io::Errno::BADF.raw_os_error())
);
assert!(!is_open(3) && !is_open(4));
assert_listen_variables_removed();
}
fn assert_listen_variables_removed() {
for var in [
"LISTEN_PID",
"LISTEN_PIDFDID",
"LISTEN_FDS",
"LISTEN_FDNAMES",
] {
assert!(env::var_os(var).is_none(), "${var} is still set");
}
}
}