use std::{
io::{self, IoSlice, IoSliceMut},
mem::MaybeUninit,
os::fd::{BorrowedFd, OwnedFd},
};
use rustix::{
cmsg_space,
io::{Errno, retry_on_intr},
net::{
AddressFamily, RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, ReturnFlags,
SendAncillaryBuffer, SendAncillaryMessage, SendFlags, SocketFlags, SocketType, recvmsg,
sendmsg, socketpair,
},
};
use crate::{Error, Result, notifier::MAX_FDS};
#[derive(Debug)]
pub(crate) struct Queue {
sending: OwnedFd,
queue: OwnedFd,
}
impl Queue {
pub(crate) fn new() -> io::Result<Self> {
let (sending, queue) = socketpair(
AddressFamily::UNIX,
SocketType::SEQPACKET,
SocketFlags::CLOEXEC,
None,
)?;
Ok(Self { sending, queue })
}
pub(crate) fn push(&self, index: u64, fds: &[BorrowedFd<'_>]) -> io::Result<bool> {
if fds.len() > MAX_FDS {
return Err(Errno::TOOBIG.into());
}
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 datagram takes"
);
}
let index = index.to_le_bytes();
let pushed = retry_on_intr(|| {
sendmsg(
&self.sending,
&[IoSlice::new(&index)],
&mut control,
SendFlags::DONTWAIT | SendFlags::NOSIGNAL,
)
});
match pushed {
Ok(_) => Ok(true),
Err(Errno::AGAIN) => Ok(false),
Err(e) => Err(e.into()),
}
}
pub(crate) fn into_socket(self) -> OwnedFd {
self.queue
}
}
pub(crate) fn take<F>(socket: BorrowedFd<'_>, mut each: F) -> Result<()>
where
F: FnMut(u64, Vec<OwnedFd>, bool),
{
loop {
let mut index = [0; INDEX_LEN];
let mut space = [MaybeUninit::uninit(); cmsg_space!(ScmRights(MAX_FDS))];
let mut control = RecvAncillaryBuffer::new(&mut space);
let received = retry_on_intr(|| {
recvmsg(
socket,
&mut [IoSliceMut::new(&mut index)],
&mut control,
RecvFlags::DONTWAIT | RecvFlags::CMSG_CLOEXEC,
)
});
let received = match received {
Ok(received) => received,
Err(Errno::AGAIN) => return Ok(()),
Err(e) => return Err(Error::os(e)),
};
if received.bytes == 0 {
return Ok(());
}
if received.bytes != INDEX_LEN || received.flags.contains(ReturnFlags::TRUNC) {
return Err(Error::InvalidHandover(
"a datagram that no queue of file descriptors pushed".to_owned(),
));
}
let fds = control
.drain()
.filter_map(|message| match message {
RecvAncillaryMessage::ScmRights(fds) => Some(fds),
_ => None,
})
.flatten()
.collect();
let complete = !received.flags.contains(ReturnFlags::CTRUNC);
each(u64::from_le_bytes(index), fds, complete);
}
}
const INDEX_LEN: usize = size_of::<u64>();
#[cfg(test)]
mod tests {
use std::os::fd::AsFd;
use rustix::{
io::{FdFlags, fcntl_getfd, write},
net::{send, sockopt::set_socket_send_buffer_size},
process::{Resource, getrlimit, setrlimit},
};
use super::*;
use crate::test_utils::{in_own_process, pipe, read_byte};
#[test]
fn round_trip() {
let (read_a, write_a) = pipe();
let (read_b, write_b) = pipe();
let queue = Queue::new().unwrap();
assert!(queue.push(7, &[write_a.as_fd(), write_b.as_fd()]).unwrap());
assert!(queue.push(9, &[]).unwrap());
assert!(queue.push(10, &[write_a.as_fd(), write_a.as_fd()]).unwrap());
let socket = queue.into_socket();
let mut taken = Vec::new();
take(socket.as_fd(), |index, fds, complete| {
assert!(complete, "not all of those at {index} came");
taken.push((index, fds));
})
.unwrap();
let [(7, first), (9, none), (10, second)] = &taken[..] else {
panic!("{taken:?} came");
};
assert!(none.is_empty());
let pairs = [
(&first[..], [(&read_a, b'a'), (&read_b, b'b')]),
(&second[..], [(&read_a, b'c'), (&read_a, b'd')]),
];
for (fds, reads) in pairs {
assert_eq!(fds.len(), reads.len());
for (fd, (read, byte)) in fds.iter().zip(reads) {
write(fd, &[byte]).unwrap();
assert_eq!(read_byte(read), byte);
assert!(fcntl_getfd(fd).unwrap().contains(FdFlags::CLOEXEC));
}
}
take(socket.as_fd(), |index, _, _| panic!("{index} came twice")).unwrap();
}
#[test]
fn fills_up() {
let queue = Queue::new().unwrap();
set_socket_send_buffer_size(&queue.sending, 1).unwrap();
let (_read, write) = pipe();
let mut pushed = 0;
while queue.push(pushed, &[write.as_fd()]).unwrap() {
pushed += 1;
assert!(
pushed < 1000,
"the queue took more than its buffer has room for"
);
}
assert!(pushed > 0);
assert!(!queue.push(pushed, &[write.as_fd(); MAX_FDS]).unwrap());
let socket = queue.into_socket();
let mut indexes = Vec::new();
take(socket.as_fd(), |index, fds, complete| {
assert!(complete && fds.len() == 1, "{index}: {fds:?}");
indexes.push(index);
})
.unwrap();
assert!(indexes.into_iter().eq(0..pushed));
}
#[test]
fn takes_max_fds_at_most() {
let queue = Queue::new().unwrap();
let (_read, write) = pipe();
let error = queue.push(0, &[write.as_fd(); MAX_FDS + 1]).unwrap_err();
assert_eq!(error.raw_os_error(), Some(Errno::TOOBIG.raw_os_error()));
assert!(queue.push(1, &[write.as_fd(); MAX_FDS]).unwrap());
let socket = queue.into_socket();
let mut taken = Vec::new();
take(socket.as_fd(), |index, fds, _| {
taken.push((index, fds.len()))
})
.unwrap();
assert_eq!(taken, [(1, MAX_FDS)]);
}
#[test]
fn open_still() {
let queue = Queue::new().unwrap();
let (_read, write) = pipe();
assert!(queue.push(3, &[write.as_fd()]).unwrap());
let mut taken = Vec::new();
take(queue.queue.as_fd(), |index, fds, _| {
taken.push((index, fds.len()))
})
.unwrap();
assert_eq!(taken, [(3, 1)]);
}
#[test]
fn other_datagrams_are_refused() {
for datagram in [&b"an index and more"[..], b"short"] {
let (sending, socket) = socketpair(
AddressFamily::UNIX,
SocketType::SEQPACKET,
SocketFlags::CLOEXEC,
None,
)
.unwrap();
assert_eq!(
send(&sending, datagram, SendFlags::empty()).unwrap(),
datagram.len()
);
let error = take(socket.as_fd(), |index, _, _| panic!("{index} came")).unwrap_err();
assert!(
matches!(error, Error::InvalidHandover(_)),
"{datagram:?}: {error:?}"
);
}
}
#[test]
fn without_room_for_all() {
let test = "queue::tests::without_room_for_all";
if !in_own_process(test, "ZOTER_TEST_LOW_NOFILE=1") {
return;
}
let queue = Queue::new().unwrap();
let (_read, write) = pipe();
assert!(queue.push(0, &[write.as_fd(); 8]).unwrap());
let socket = queue.into_socket();
let open = std::fs::read_dir("/proc/self/fd").unwrap().count() as u64;
let mut limit = getrlimit(Resource::Nofile);
limit.current = Some(open + 2);
setrlimit(Resource::Nofile, limit).unwrap();
let mut taken = Vec::new();
take(socket.as_fd(), |index, fds, complete| {
taken.push((index, fds.len(), complete))
})
.unwrap();
let [(0, came, false)] = taken[..] else {
panic!("{taken:?} came");
};
assert!(0 < came && came < 8, "{came} came");
}
}