use std::{
env,
ffi::OsStr,
io::IoSlice,
mem::MaybeUninit,
os::{
fd::{AsFd, BorrowedFd, OwnedFd},
unix::ffi::OsStrExt,
},
time::{Duration, Instant},
};
use rustix::{
cmsg_space,
event::{PollFd, PollFlags, Timespec, poll},
io::{Errno, retry_on_intr},
net::{
AddressFamily, SendAncillaryBuffer, SendAncillaryMessage, SendFlags, SocketAddrUnix,
SocketFlags, SocketType, sendmsg_addr, socket_with,
},
pipe::{PipeFlags, pipe_with},
};
use crate::{Error, Result};
#[derive(Debug)]
pub(crate) struct Notifier {
socket: OwnedFd,
address: SocketAddrUnix,
}
impl Notifier {
pub(crate) fn from_env() -> Result<Option<Self>> {
match env::var_os("NOTIFY_SOCKET") {
Some(address) if !address.is_empty() => Self::new(address).map(Some),
_ => Ok(None),
}
}
pub(crate) fn new(address: impl AsRef<OsStr>) -> Result<Self> {
let address = match address.as_ref().as_bytes() {
[b'/' | b'@'] => {
return Err(Error::Environment(
"the notification socket has no name".to_owned(),
));
}
path @ [b'/', ..] => SocketAddrUnix::new(path).map_err(Error::os)?,
[b'@', name @ ..] => SocketAddrUnix::new_abstract_name(name).map_err(Error::os)?,
other => {
return Err(Error::Environment(format!(
"the notification socket `{}` is neither a path nor an abstract name",
String::from_utf8_lossy(other),
)));
}
};
let socket = socket_with(
AddressFamily::UNIX,
SocketType::DGRAM,
SocketFlags::CLOEXEC,
None,
)
.map_err(Error::os)?;
Ok(Self { socket, address })
}
pub(crate) fn store(&self, name: &str, fds: &[BorrowedFd<'_>]) -> Result<()> {
check_name(name)?;
self.notify_with_fds(&format!("FDSTORE=1\nFDPOLL=0\nFDNAME={name}"), fds)
}
pub(crate) fn remove(&self, name: &str) -> Result<()> {
check_name(name)?;
self.notify(&format!("FDSTOREREMOVE=1\nFDNAME={name}"))
}
pub(crate) fn notify(&self, state: &str) -> Result<()> {
self.notify_with_fds(state, &[])
}
pub(crate) fn barrier(&self, timeout: Duration) -> Result<()> {
let deadline = Instant::now().checked_add(timeout);
let read = {
let (read, write) = pipe_with(PipeFlags::CLOEXEC).map_err(Error::os)?;
self.notify_with_fds("BARRIER=1", &[write.as_fd()])?;
read
};
let mut fds = [PollFd::new(&read, PollFlags::empty())];
match retry_on_intr(|| poll(&mut fds, remaining(deadline).as_ref())).map_err(Error::os)? {
0 => Err(Error::TimedOut),
_ => Ok(()),
}
}
fn notify_with_fds(&self, state: &str, fds: &[BorrowedFd<'_>]) -> Result<()> {
if fds.len() > MAX_FDS {
return Err(Error::os(Errno::TOOBIG));
}
let mut space = [MaybeUninit::uninit(); cmsg_space!(ScmRights(MAX_FDS))];
let mut control = SendAncillaryBuffer::new(&mut space);
if !fds.is_empty() {
let fits = control.push(SendAncillaryMessage::ScmRights(fds));
debug_assert!(
fits,
"the space is for as many file descriptors as a message takes"
);
}
let state = [IoSlice::new(state.as_bytes())];
sendmsg_addr(
&self.socket,
&self.address,
&state,
&mut control,
SendFlags::NOSIGNAL,
)
.map_err(Error::os)?;
Ok(())
}
}
pub(crate) fn check_name(name: &str) -> Result<()> {
let printable = |b: u8| (b' '..=b'~').contains(&b) && b != b':';
if name.is_empty() || name.len() > MAX_NAME_LEN || !name.bytes().all(printable) {
return Err(Error::InvalidName(format!(
"a file descriptor name is 1 to {MAX_NAME_LEN} printable ASCII characters, other \
than `:`"
)));
}
Ok(())
}
fn remaining(deadline: Option<Instant>) -> Option<Timespec> {
let left = deadline?.saturating_duration_since(Instant::now());
Timespec::try_from(left).ok()
}
pub(crate) const MAX_FDS: usize = 253;
pub(crate) const MAX_NAME_LEN: usize = 255;
#[cfg(test)]
mod tests {
use std::{fs::remove_file, io::IoSliceMut, path::PathBuf, sync::mpsc::channel, thread};
use rustix::{
io::write,
net::{
RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, ReturnFlags, bind, recvmsg,
sockopt::{Timeout, set_socket_timeout},
},
};
use super::*;
use crate::test_utils::{in_own_process, pipe, read_byte, unique_name, unique_path};
#[test]
fn valid_names() {
let longest = "a".repeat(MAX_NAME_LEN);
let printable = ('!'..='~').filter(|c| *c != ':').collect::<String>();
for name in ["x", "busd/fds", "with spaces", &printable, &longest] {
check_name(name).unwrap_or_else(|e| panic!("{name:?}: {e}"));
}
}
#[test]
fn invalid_names() {
let too_long = "a".repeat(MAX_NAME_LEN + 1);
let invalid = [
"",
"a:b",
":",
"a\nb",
"a\rb",
"a\tb",
"a\0b",
"a\x1fb",
"a\x7fb",
"é",
"日本",
"x\nFDSTOREREMOVE=1",
&too_long,
];
for name in invalid {
let error = check_name(name).unwrap_err();
assert!(
matches!(error, Error::InvalidName(_)),
"{name:?}: {error:?}"
);
}
}
#[test]
fn notify() {
for (manager, notifier) in managers() {
notifier.notify("READY=1\nSTATUS=Up").unwrap();
let (state, fds) = manager.receive();
assert_eq!(state, "READY=1\nSTATUS=Up");
assert!(fds.is_empty());
}
}
#[test]
fn store() {
for (manager, notifier) in managers() {
let (read_a, write_a) = pipe();
let (read_b, write_b) = pipe();
notifier
.store("x", &[write_a.as_fd(), write_b.as_fd()])
.unwrap();
let (state, fds) = manager.receive();
assert_eq!(state, "FDSTORE=1\nFDPOLL=0\nFDNAME=x");
assert_eq!(fds.len(), 2);
write(&fds[0], b"a").unwrap();
write(&fds[1], b"b").unwrap();
assert_eq!(read_byte(&read_a), b'a');
assert_eq!(read_byte(&read_b), b'b');
}
}
#[test]
fn remove() {
for (manager, notifier) in managers() {
notifier.remove("x y").unwrap();
let (state, fds) = manager.receive();
assert_eq!(state, "FDSTOREREMOVE=1\nFDNAME=x y");
assert!(fds.is_empty());
}
}
#[test]
fn invalid_names_are_not_sent() {
for (manager, notifier) in managers() {
let (_read, write) = pipe();
let error = notifier.store("a:b", &[write.as_fd()]).unwrap_err();
assert!(matches!(error, Error::InvalidName(_)), "{error:?}");
let error = notifier.remove("").unwrap_err();
assert!(matches!(error, Error::InvalidName(_)), "{error:?}");
notifier.notify("READY=1").unwrap();
let (state, fds) = manager.receive();
assert_eq!(state, "READY=1");
assert!(fds.is_empty());
}
}
#[test]
fn notify_the_most_file_descriptors() {
for (manager, notifier) in managers() {
let (_read, write) = pipe();
let fd = write.as_fd();
notifier.notify_with_fds("READY=1", &[fd; MAX_FDS]).unwrap();
assert_eq!(manager.receive().1.len(), MAX_FDS);
let error = notifier
.notify_with_fds("READY=1", &[fd; MAX_FDS + 1])
.unwrap_err();
assert_eq!(os_error(error), Errno::TOOBIG);
notifier.notify("STATUS=Next").unwrap();
assert_eq!(manager.receive().0, "STATUS=Next");
}
}
#[test]
fn notify_without_a_manager() {
let notifier = Notifier::new(unique_path()).unwrap();
let error = notifier.notify("READY=1").unwrap_err();
assert_eq!(os_error(error), Errno::NOENT);
let error = notifier.barrier(Duration::from_secs(1)).unwrap_err();
assert_eq!(os_error(error), Errno::NOENT);
}
#[test]
fn addresses() {
Notifier::new("/run/systemd/notify").unwrap();
Notifier::new("@/org/freedesktop/systemd1/notify").unwrap();
Notifier::new(format!("/{}", "a".repeat(107))).unwrap();
Notifier::new(format!("@{}", "a".repeat(107))).unwrap();
for address in ["/", "@"] {
let error = Notifier::new(address).unwrap_err();
assert!(
matches!(error, Error::Environment(_)),
"{address:?}: {error:?}"
);
}
for address in [
"",
"x",
"relative/path",
"unix:/run/notify",
"vsock:2:1234",
"vsock-stream:2:1234",
] {
let error = Notifier::new(address).unwrap_err();
assert!(
matches!(error, Error::Environment(_)),
"{address:?}: {error:?}"
);
}
for address in [
format!("/{}", "a".repeat(108)),
format!("@{}", "a".repeat(108)),
] {
let error = Notifier::new(&address).unwrap_err();
assert_eq!(os_error(error), Errno::NAMETOOLONG, "{address:?}");
}
}
#[test]
fn from_the_environment() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify";
if !in_own_process("notifier::tests::from_the_environment", exports) {
return;
}
assert!(Notifier::from_env().unwrap().is_some());
assert!(env::var_os("NOTIFY_SOCKET").is_some());
unsafe { env::set_var("NOTIFY_SOCKET", "") };
assert!(Notifier::from_env().unwrap().is_none());
unsafe { env::remove_var("NOTIFY_SOCKET") };
assert!(Notifier::from_env().unwrap().is_none());
unsafe { env::set_var("NOTIFY_SOCKET", "vsock:2:1234") };
let error = Notifier::from_env().unwrap_err();
assert!(matches!(error, Error::Environment(_)), "{error:?}");
}
#[test]
fn barrier_waits_for_the_manager() {
for (manager, notifier) in managers() {
let delay = Duration::from_millis(200);
let manager = thread::spawn(move || {
let (state, fds) = manager.receive();
thread::sleep(delay);
(state, fds.len())
});
let start = Instant::now();
notifier.barrier(Duration::from_secs(30)).unwrap();
assert!(start.elapsed() >= delay, "{:?}", start.elapsed());
assert_eq!(manager.join().unwrap(), ("BARRIER=1".to_owned(), 1));
}
}
#[test]
fn barrier_times_out() {
for (manager, notifier) in managers() {
let (release, released) = channel::<()>();
let manager = thread::spawn(move || {
let (state, fds) = manager.receive();
let _ = released.recv();
(state, fds.len())
});
let timeout = Duration::from_millis(200);
let start = Instant::now();
let error = notifier.barrier(timeout).unwrap_err();
assert!(matches!(error, Error::TimedOut), "{error:?}");
assert!(start.elapsed() >= timeout, "{:?}", start.elapsed());
release.send(()).unwrap();
assert_eq!(manager.join().unwrap(), ("BARRIER=1".to_owned(), 1));
}
}
fn os_error(error: Error) -> Errno {
let Error::Io(error) = error else {
panic!("{error:?} isn't an error of the system");
};
Errno::from_io_error(&error).unwrap_or_else(|| panic!("{error:?}"))
}
fn managers() -> [(Manager, Notifier); 2] {
[Manager::at_path(), Manager::at_abstract_name()]
}
struct Manager {
socket: OwnedFd,
path: Option<PathBuf>,
}
impl Manager {
fn at_path() -> (Self, Notifier) {
let path = unique_path();
let address = SocketAddrUnix::new(&path).unwrap();
let manager = Self::bind(&address, Some(path.clone()));
(manager, Notifier::new(&path).unwrap())
}
fn at_abstract_name() -> (Self, Notifier) {
let name = unique_name();
let address = SocketAddrUnix::new_abstract_name(name.as_bytes()).unwrap();
let manager = Self::bind(&address, None);
(manager, Notifier::new(format!("@{name}")).unwrap())
}
fn bind(address: &SocketAddrUnix, path: Option<PathBuf>) -> Self {
let socket = socket_with(
AddressFamily::UNIX,
SocketType::DGRAM,
SocketFlags::CLOEXEC,
None,
)
.unwrap();
bind(&socket, address).unwrap();
set_socket_timeout(&socket, Timeout::Recv, Some(Duration::from_secs(10))).unwrap();
Self { socket, path }
}
fn receive(&self) -> (String, Vec<OwnedFd>) {
let mut text = [0; 8192];
let mut space = [MaybeUninit::uninit(); cmsg_space!(ScmRights(MAX_FDS))];
let mut control = RecvAncillaryBuffer::new(&mut space);
let message = recvmsg(
&self.socket,
&mut [IoSliceMut::new(&mut text)],
&mut control,
RecvFlags::CMSG_CLOEXEC,
)
.unwrap();
assert!(
!message
.flags
.intersects(ReturnFlags::TRUNC | ReturnFlags::CTRUNC)
);
let mut fds = Vec::new();
for message in control.drain() {
if let RecvAncillaryMessage::ScmRights(received) = message {
fds.extend(received);
}
}
(
String::from_utf8(text[..message.bytes].to_vec()).unwrap(),
fds,
)
}
}
impl Drop for Manager {
fn drop(&mut self) {
if let Some(path) = &self.path {
let _ = remove_file(path);
}
}
}
}