use std::{
collections::VecDeque,
fmt,
future::{Future, poll_fn},
io, iter, mem,
net::TcpStream,
num::NonZeroU32,
os::{
fd::{AsFd, BorrowedFd, OwnedFd},
unix::net::UnixStream,
},
pin::{Pin, pin},
str,
sync::{
Arc, Mutex, PoisonError,
atomic::{AtomicBool, Ordering},
},
task::Poll,
};
use futures_core::Stream;
use zruntime::{
Event, EventListener,
broadcast::{Receiver, TryRecvError},
};
use super::socket_write::Unwritten;
use crate::{
Connection, Error, Guid, Message, OwnedGuid, Result,
connection::socket::{BoxedSplit, ReadHalf, Split, read_primary_header},
message::{self, header::MIN_MESSAGE_SIZE},
names::OwnedUniqueName,
runtime::IoSource,
wire::{
Endian, LE,
serialized::{Context, Data},
},
};
#[must_use = "dropping a `Handover` closes the descriptors that it holds, which disconnects the \
peer unless they were passed on"]
pub struct Handover {
pub(super) socket: HandoverSocket,
pub(super) server_guid: OwnedGuid,
pub(super) unique_name: Option<OwnedUniqueName>,
pub(super) unix_fd_passing: bool,
#[cfg(feature = "p2p")]
pub(super) p2p: bool,
pub(super) next_serial: NonZeroU32,
pub(super) queued: Vec<Message>,
pub(super) tail: Vec<u8>,
pub(super) tail_fds: Vec<OwnedFd>,
pub(super) unwritten: Unwritten,
}
impl Handover {
pub fn unread_len(&self) -> usize {
len_of(&self.queued) + self.tail.len()
}
pub fn unwritten_len(&self) -> usize {
self.unwritten.len()
}
}
impl zoter::Save for Handover {
fn saved_len(&self) -> Option<usize> {
match self.socket {
HandoverSocket::Socket(_) => None,
_ => Some(self.layout().len),
}
}
fn save(&self, dest: &mut [u8]) -> io::Result<()> {
let kind = match &self.socket {
HandoverSocket::UnixStream(_) => UNIX_STREAM,
HandoverSocket::TcpStream(_) => TCP_STREAM,
HandoverSocket::Socket(_) => {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"the hand-over of a connection over a socket of your own has no record",
));
}
};
let layout = self.layout();
if dest.len() != layout.len {
return Err(invalid_input("the memory is not as long as the record"));
}
let kept = &self.unwritten.kept;
let counts = [
fd_count_of(&self.queued) + self.tail_fds.len() + fd_count_of(kept),
self.queued.len(),
self.tail_fds.len(),
kept.len(),
];
let mut table = self
.queued
.iter()
.chain(kept)
.flat_map(|msg| [msg.data().len(), msg.data().fds().len()]);
if counts
.iter()
.copied()
.chain(&mut table)
.any(|count| u32::try_from(count).is_err())
{
return Err(invalid_input(
"too many messages or file descriptors for a record",
));
}
let name = self.unique_name.as_ref().map_or("", |name| name.as_str());
let mut flags = 0;
if self.unix_fd_passing {
flags |= FD_PASSING;
}
#[cfg(feature = "p2p")]
if self.p2p {
flags |= P2P;
}
let mut guid = [0; 32];
uuid::Uuid::try_parse(self.server_guid.as_str())
.expect("a GUID is a UUID")
.as_simple()
.encode_lower(&mut guid);
let rest = self.unwritten.rest();
let mut record = Record(dest);
record.put(MAGIC);
record.put(&MAJOR.to_le_bytes());
record.put(&(layout.header_len as u16).to_le_bytes());
record.put(&0u32.to_le_bytes());
record.put(&(layout.len as u64).to_le_bytes());
record.put(&[kind, flags, name.len() as u8, 0]);
record.put(&self.next_serial.get().to_le_bytes());
for count in counts {
record.put(&(count as u32).to_le_bytes());
}
for len in [layout.inbound, layout.outbound, rest.len()] {
record.put(&(len as u64).to_le_bytes());
}
record.put(&guid);
record.put(name.as_bytes());
record.zeros(layout.header_len - NAME - name.len());
for msg in self.queued.iter().chain(kept) {
record.put(&(msg.data().len() as u32).to_le_bytes());
record.put(&(msg.data().fds().len() as u32).to_le_bytes());
}
for msg in &self.queued {
record.put(msg.data());
}
record.put(&self.tail);
record.zeros(layout.inbound.next_multiple_of(8) - layout.inbound);
record.put(rest);
for msg in kept {
record.put(msg.data());
}
record.zeros(layout.outbound.next_multiple_of(8) - layout.outbound);
debug_assert!(
record.0.is_empty(),
"the record is longer than what was copied into it"
);
Ok(())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
let socket = match &self.socket {
HandoverSocket::UnixStream(socket) => socket.as_fd(),
HandoverSocket::TcpStream(socket) => socket.as_fd(),
HandoverSocket::Socket(_) => return Vec::new(),
};
let kept = &self.unwritten.kept;
iter::once(socket)
.chain(fds_of(&self.queued))
.chain(self.tail_fds.iter().map(AsFd::as_fd))
.chain(fds_of(kept))
.collect()
}
}
impl zoter::Restore for Handover {
type Error = Error;
fn restore(record: &[u8], fds: Vec<OwnedFd>) -> Result<Handover> {
if record.get(..MAGIC.len()) != Some(MAGIC) {
return Err(malformed());
}
match u16::from_le_bytes(field(record, 8)?) {
MAJOR => (),
major if major > MAJOR => return Err(Error::Unsupported),
_ => return Err(malformed()),
}
if u32::from_le_bytes(field(record, 12)?) & !KNOWN_FEATURES != 0 {
return Err(Error::Unsupported);
}
let [kind, flags, name_len, _] = field(record, 24)?;
#[cfg(not(feature = "p2p"))]
if flags & P2P != 0 {
return Err(Error::Unsupported);
}
let header_len = usize::from(u16::from_le_bytes(field(record, 10)?));
let name_len = usize::from(name_len);
if header_len % 8 != 0
|| header_len < (NAME + name_len).next_multiple_of(8)
|| len_at(record, 16)? != record.len()
{
return Err(malformed());
}
let next_serial = NonZeroU32::new(u32::from_le_bytes(field(record, 28)?));
let next_serial = next_serial.ok_or_else(malformed)?;
let count_at = |at| field(record, at).map(|count| u32::from_le_bytes(count) as usize);
let (fd_count, queued, tail_fds, kept) =
(count_at(32)?, count_at(36)?, count_at(40)?, count_at(44)?);
let (inbound, outbound) = (len_at(record, 48)?, len_at(record, 56)?);
let rest = len_at(record, 64)?;
if fds.len().checked_sub(1) != Some(fd_count) {
return Err(malformed());
}
let server_guid = str::from_utf8(bytes(record, 72, 32)?).map_err(|_| malformed())?;
let server_guid = Guid::try_from(server_guid).map_err(|_| malformed())?;
let unique_name = match bytes(record, NAME, name_len)? {
[] => None,
name => {
let name = str::from_utf8(name).map_err(|_| malformed())?;
Some(OwnedUniqueName::try_from(name).map_err(|_| malformed())?)
}
};
let table_len = queued
.checked_add(kept)
.and_then(|entries| entries.checked_mul(8))
.ok_or_else(malformed)?;
let table = bytes(record, header_len, table_len)?;
let (mut inbound, inbound_end) = section(record, header_len + table_len, inbound)?;
let (outbound, end) = section(record, inbound_end, outbound)?;
if end != record.len() {
return Err(malformed());
}
let (rest, mut outbound) = outbound.split_at_checked(rest).ok_or_else(malformed)?;
let (queued_table, kept_table) = table.split_at(8 * queued);
let mut fds = fds.into_iter();
let socket = fds.next().expect("the descriptors were counted");
let socket = match kind {
UNIX_STREAM => HandoverSocket::UnixStream(UnixStream::from(socket)),
TCP_STREAM => HandoverSocket::TcpStream(TcpStream::from(socket)),
_ => return Err(malformed()),
};
let queued = queued_table
.as_chunks::<8>()
.0
.iter()
.map(|entry| framed(entry, &mut inbound, &mut fds))
.collect::<Result<Vec<_>>>()?;
let tail = inbound.to_vec();
let tail_fds: Vec<_> = fds.by_ref().take(tail_fds).collect();
let tail_fds_counted = tail_fds.len() == count_at(40)?;
let kept = kept_table
.as_chunks::<8>()
.0
.iter()
.map(|entry| framed(entry, &mut outbound, &mut fds))
.collect::<Result<VecDeque<_>>>()?;
if !outbound.is_empty() || !tail_fds_counted || fds.next().is_some() {
return Err(malformed());
}
let cut = (!rest.is_empty()).then(|| (Data::new(rest.to_vec(), Context::new(LE, 0)), 0));
Ok(Handover {
socket,
server_guid: server_guid.to_owned().into(),
unique_name,
unix_fd_passing: flags & FD_PASSING != 0,
#[cfg(feature = "p2p")]
p2p: flags & P2P != 0,
next_serial,
queued,
tail,
tail_fds,
unwritten: Unwritten { cut, kept },
})
}
}
impl Handover {
fn layout(&self) -> Layout {
let name = self
.unique_name
.as_ref()
.map_or(0, |name| name.as_str().len());
let header_len = (NAME + name).next_multiple_of(8);
let kept = &self.unwritten.kept;
let table_len = 8 * (self.queued.len() + kept.len());
let inbound = len_of(&self.queued) + self.tail.len();
let outbound = self.unwritten.rest().len() + len_of(kept);
let len =
header_len + table_len + inbound.next_multiple_of(8) + outbound.next_multiple_of(8);
Layout {
header_len,
inbound,
outbound,
len,
}
}
}
impl fmt::Debug for Handover {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let kept = &self.unwritten.kept;
f.debug_struct("Handover")
.field("socket", &self.socket)
.field("unique_name", &self.unique_name)
.field("unread_len", &self.unread_len())
.field(
"unread_fds",
&(fd_count_of(&self.queued) + self.tail_fds.len()),
)
.field("unwritten_len", &self.unwritten_len())
.field("unwritten_fds", &fd_count_of(kept))
.finish_non_exhaustive()
}
}
pub(super) enum HandoverSocket {
UnixStream(UnixStream),
TcpStream(TcpStream),
Socket(BoxedSplit),
}
impl fmt::Debug for HandoverSocket {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnixStream(socket) => f.debug_tuple("UnixStream").field(socket).finish(),
Self::TcpStream(socket) => f.debug_tuple("TcpStream").field(socket).finish(),
Self::Socket(_) => f.write_str("Socket"),
}
}
}
impl Connection {
pub(crate) async fn hand_over(
&self,
queue: &mut Receiver<Result<Message>>,
backlog: &mut Backlog,
) -> Result<Handover> {
self.ensure_whole().await?;
let stream = backlog.stream.get_or_insert_with(Default::default);
self.claim(stream)?;
self.prepare_hand_over();
self.stop_reading();
self.take_queue_until_stopped(queue, &mut backlog.items)
.await;
self.take_apart(&mut backlog.items).await
}
async fn ensure_whole(&self) -> Result<()> {
let mut lock = pin!(self.inner.socket_write.lock());
let write = poll_fn(|cx| Poll::Ready(lock.as_mut().poll(cx))).await;
if matches!(write, Poll::Ready(write) if write.is_torn()) {
return Err(torn());
}
Ok(())
}
fn claim(&self, stream: &Arc<()>) -> Result<()> {
let stop = &self.inner.socket_status.stop;
if !stop.can_stop.load(Ordering::Acquire) {
return Err(Error::Unsupported);
}
stop.claim(stream)
}
fn stop_reading(&self) {
if self.inner.is_closed() {
return;
}
let stop = &self.inner.socket_status.stop;
if !stop.asked.swap(true, Ordering::AcqRel) {
stop.asked_event.notify(usize::MAX);
}
}
async fn take_queue_until_stopped(
&self,
queue: &mut Receiver<Result<Message>>,
taken: &mut VecDeque<Result<Message>>,
) {
let inner = &*self.inner;
let stop = &inner.socket_status.stop;
loop {
let mut ended = stop.reader_end_event.listen();
let mut closed = inner.closed_listener();
if !stop.reading() || inner.is_closed() {
break;
}
poll_fn(|cx| {
while let Poll::Ready(Some(msg)) = Pin::new(&mut *queue).poll_next(cx) {
taken.push_back(msg);
}
if Pin::new(&mut ended).poll(cx).is_ready()
|| Pin::new(&mut closed).poll(cx).is_ready()
{
return Poll::Ready(());
}
Poll::Pending
})
.await;
}
loop {
match queue.try_recv() {
Ok(msg) => taken.push_back(msg),
Err(TryRecvError::Overflowed(_)) => continue,
Err(TryRecvError::Empty | TryRecvError::Closed) => break,
}
}
}
async fn take_apart(&self, taken: &mut VecDeque<Result<Message>>) -> Result<Handover> {
let inner = &*self.inner;
let stop = &inner.socket_status.stop;
let mut guard = inner.socket_write.lock().await;
let write = &mut *guard;
let mut end = stop
.reader_end
.lock()
.unwrap_or_else(PoisonError::into_inner);
if matches!(*end, ReaderEnd::HandedOver) {
return Err(not_connected("the connection was handed over already").into());
}
if write.is_shut_down() {
return Err(not_connected("the connection was closed").into());
}
if !matches!(*end, ReaderEnd::Stopped(_) | ReaderEnd::Ended(_)) {
return Err(not_connected("the connection ended before it stopped reading").into());
}
if write.is_torn() {
return Err(torn());
}
let duplicate = write
.source()
.map(|(source, kind)| dup(source).map(|socket| (socket, *kind)))
.transpose()?;
let (ReaderEnd::Stopped(parts) | ReaderEnd::Ended(parts)) =
mem::replace(&mut *end, ReaderEnd::HandedOver)
else {
unreachable!("the reader stopped or ended, as the hand-over found under its lock");
};
drop(end);
stop.reader_end_event.notify(usize::MAX);
let (write_half, writes, unwritten) = write
.take_half()
.expect("the write half is only taken by a hand-over, which there was none of");
inner.socket_status.closed.store(true, Ordering::Release);
inner.socket_status.closed_event.notify(usize::MAX);
drop(guard);
let ReadParts {
half: read_half,
queued: taken_over,
unread_bytes: tail,
unread_fds: tail_fds,
} = parts;
let mut queued: Vec<Message> = taken.drain(..).flatten().collect();
queued.extend(taken_over);
let socket = match duplicate {
Some((socket, kind)) => {
drop(read_half);
drop(write_half);
drop(writes);
kind.stream(socket)
}
None => HandoverSocket::Socket(Split::with_writes(read_half, write_half, writes)),
};
Ok(Handover {
socket,
server_guid: inner.server_guid.clone(),
unique_name: self.unique_name().cloned(),
unix_fd_passing: inner.cap_unix_fd,
#[cfg(feature = "p2p")]
p2p: !self.is_bus(),
next_serial: message::header::next_serial(),
queued,
tail,
tail_fds,
unwritten,
})
}
}
#[derive(Debug, Default)]
pub(crate) struct Backlog {
items: VecDeque<Result<Message>>,
stream: Option<Arc<()>>,
}
impl Backlog {
pub(crate) fn pop(&mut self) -> Option<Result<Message>> {
self.items.pop_front()
}
pub(crate) fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
impl Clone for Backlog {
fn clone(&self) -> Self {
Self {
items: self.items.clone(),
stream: None,
}
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum SocketKind {
Unix,
Tcp,
}
impl SocketKind {
fn stream(self, socket: OwnedFd) -> HandoverSocket {
match self {
Self::Unix => HandoverSocket::UnixStream(UnixStream::from(socket)),
Self::Tcp => HandoverSocket::TcpStream(TcpStream::from(socket)),
}
}
}
#[derive(Debug)]
pub(super) struct StopStatus {
pub can_stop: AtomicBool,
asked: AtomicBool,
asked_event: Event,
stream: Mutex<Option<Arc<()>>>,
reader_end: Mutex<ReaderEnd>,
reader_end_event: Event,
}
impl StopStatus {
pub(super) fn new() -> Self {
Self {
can_stop: AtomicBool::new(false),
asked: AtomicBool::new(false),
asked_event: Event::new(),
stream: Mutex::new(None),
reader_end: Mutex::new(ReaderEnd::Reading),
reader_end_event: Event::new(),
}
}
pub(super) fn listener(&self) -> Option<EventListener> {
self.can_stop
.load(Ordering::Acquire)
.then(|| self.asked_event.listen())
}
pub(super) fn ensure_reading(&self) -> Result<()> {
if self.asked() {
return Err(stopped_error());
}
Ok(())
}
pub(super) fn asked(&self) -> bool {
self.asked.load(Ordering::Acquire)
}
pub(super) fn end_reading(&self, end: ReaderEnd) {
let mut slot = self
.reader_end
.lock()
.unwrap_or_else(PoisonError::into_inner);
if !matches!(*slot, ReaderEnd::Reading) {
return;
}
*slot = end;
drop(slot);
self.reader_end_event.notify(usize::MAX);
}
fn claim(&self, stream: &Arc<()>) -> Result<()> {
let mut claimed = self.stream.lock().unwrap_or_else(PoisonError::into_inner);
match &*claimed {
Some(claimed) if !Arc::ptr_eq(claimed, stream) => Err(not_connected(
"a hand-over through another stream of the connection may have taken messages off \
that stream",
)
.into()),
Some(_) => Ok(()),
None => {
*claimed = Some(stream.clone());
Ok(())
}
}
}
fn reading(&self) -> bool {
matches!(
*self
.reader_end
.lock()
.unwrap_or_else(PoisonError::into_inner),
ReaderEnd::Reading
)
}
}
pub(super) enum ReaderEnd {
Reading,
Stopped(ReadParts),
Ended(ReadParts),
Failed,
HandedOver,
}
impl fmt::Debug for ReaderEnd {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (name, parts) = match self {
Self::Reading => return f.write_str("Reading"),
Self::Stopped(parts) => ("Stopped", parts),
Self::Ended(parts) => ("Ended", parts),
Self::Failed => return f.write_str("Failed"),
Self::HandedOver => return f.write_str("HandedOver"),
};
let mut left = f.debug_struct(name);
left.field("half", &parts.half)
.field("queued", &parts.queued.len())
.field("unread_bytes", &parts.unread_bytes.len());
left.field("unread_fds", &parts.unread_fds.len());
left.finish()
}
}
pub(super) struct ReadParts {
pub half: Box<dyn ReadHalf>,
pub queued: VecDeque<Message>,
pub unread_bytes: Vec<u8>,
pub unread_fds: Vec<OwnedFd>,
}
impl ReadParts {
pub(super) fn new(
mut half: Box<dyn ReadHalf>,
queued: VecDeque<Message>,
mut unread_bytes: Vec<u8>,
mut unread_fds: Vec<OwnedFd>,
) -> Self {
half.take_unread(&mut unread_bytes, &mut unread_fds);
Self {
half,
queued,
unread_bytes,
unread_fds,
}
}
}
pub(super) fn ends_input(error: &Error) -> bool {
matches!(error, Error::InputOutput(e) if e.kind() == io::ErrorKind::UnexpectedEof)
}
pub(super) fn stopped_error() -> Error {
io::Error::new(
io::ErrorKind::NotConnected,
"the connection stopped reading",
)
.into()
}
fn dup(source: &IoSource) -> io::Result<OwnedFd> {
source.as_fd().try_clone_to_owned()
}
fn len_of<'m>(msgs: impl IntoIterator<Item = &'m Message>) -> usize {
msgs.into_iter().map(|msg| msg.data().len()).sum()
}
fn fd_count_of<'m>(msgs: impl IntoIterator<Item = &'m Message>) -> usize {
msgs.into_iter().map(|msg| msg.data().fds().len()).sum()
}
fn fds_of<'m>(msgs: impl IntoIterator<Item = &'m Message>) -> impl Iterator<Item = BorrowedFd<'m>> {
msgs.into_iter()
.flat_map(|msg| msg.data().fds())
.map(AsFd::as_fd)
}
struct Layout {
header_len: usize,
inbound: usize,
outbound: usize,
len: usize,
}
struct Record<'d>(&'d mut [u8]);
impl Record<'_> {
fn put(&mut self, bytes: &[u8]) {
let (head, rest) = mem::take(&mut self.0).split_at_mut(bytes.len());
head.copy_from_slice(bytes);
self.0 = rest;
}
fn zeros(&mut self, len: usize) {
let (head, rest) = mem::take(&mut self.0).split_at_mut(len);
head.fill(0);
self.0 = rest;
}
}
fn field<const N: usize>(record: &[u8], at: usize) -> Result<[u8; N]> {
let bytes = bytes(record, at, N)?;
Ok(bytes
.try_into()
.expect("the bytes of a field are as many as it has"))
}
fn len_at(record: &[u8], at: usize) -> Result<usize> {
usize::try_from(u64::from_le_bytes(field(record, at)?)).map_err(|_| malformed())
}
fn bytes(record: &[u8], at: usize, len: usize) -> Result<&[u8]> {
at.checked_add(len)
.and_then(|end| record.get(at..end))
.ok_or_else(malformed)
}
fn section(record: &[u8], at: usize, len: usize) -> Result<(&[u8], usize)> {
let padded = len.checked_next_multiple_of(8).ok_or_else(malformed)?;
let (section, padding) = bytes(record, at, padded)?.split_at(len);
if padding.iter().any(|byte| *byte != 0) {
return Err(malformed());
}
Ok((section, at + padded))
}
fn framed(
entry: &[u8],
bytes: &mut &[u8],
fds: &mut impl Iterator<Item = OwnedFd>,
) -> Result<Message> {
let (len, count) = entry.split_at(4);
let len = u32::from_le_bytes(len.try_into().expect("4 bytes")) as usize;
let count = u32::from_le_bytes(count.try_into().expect("4 bytes")) as usize;
let (msg, rest) = bytes.split_at_checked(len).ok_or_else(malformed)?;
*bytes = rest;
if len < MIN_MESSAGE_SIZE {
return Err(malformed());
}
let (primary_header, whole) = read_primary_header(msg).map_err(|_| malformed())?;
let msg_fds: Vec<_> = fds.by_ref().take(count).collect();
if whole != len || msg_fds.len() != count {
return Err(malformed());
}
let ctxt = Context::new(Endian::from(primary_header.endian_sig()), 0);
let data = Data::new_fds(msg.to_vec(), ctxt, msg_fds);
let msg = Message::from_raw_parts(data, 0).map_err(|_| malformed())?;
if msg.header().unix_fds().unwrap_or(0) as usize != count {
return Err(malformed());
}
Ok(msg)
}
fn malformed() -> Error {
io::Error::new(
io::ErrorKind::InvalidData,
"not the record of a hand-over and its file descriptors",
)
.into()
}
fn invalid_input(reason: &'static str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, reason)
}
const MAGIC: &[u8; 8] = b"zbus-hov";
const MAJOR: u16 = 1;
const KNOWN_FEATURES: u32 = 0;
const NAME: usize = 104;
const UNIX_STREAM: u8 = 0;
const TCP_STREAM: u8 = 1;
const FD_PASSING: u8 = 1;
const P2P: u8 = 2;
fn torn() -> Error {
io::Error::new(
io::ErrorKind::InvalidData,
"a send was cut off midway: the socket may hold part of a message",
)
.into()
}
fn not_connected(reason: &'static str) -> io::Error {
io::Error::new(io::ErrorKind::NotConnected, reason)
}
#[cfg(all(test, feature = "p2p"))]
mod tests {
use std::{
collections::VecDeque,
fmt::Debug,
future::Future,
io::{self, ErrorKind, IoSlice, Read, Write},
mem::MaybeUninit,
net::{Ipv4Addr, Shutdown, TcpListener, TcpStream},
num::{NonZeroU32, NonZeroUsize},
os::{
fd::{AsFd, BorrowedFd, OwnedFd},
unix::net::{UnixListener, UnixStream},
},
pin::{Pin, pin},
sync::Arc,
thread,
time::Duration,
};
use futures_util::StreamExt;
use ntest::timeout;
use test_log::test;
use zoter::{Restore, Save};
use super::{Handover, HandoverSocket, MAJOR, NAME, ReaderEnd, TCP_STREAM, UNIX_STREAM};
use crate::{
Address, Connection, Error, Guid, MatchRule, Message, MessageStream, Result,
address::transport::{Transport, Unix, UnixSocket},
connection::{
AuthMechanism, Builder,
socket::{BoxedSplit, Channel, ReadHalf, RecvmsgResult, Split, WriteHalf},
socket_write::Unwritten,
},
message::{Type, header::next_serial},
runtime::{
Runtime,
io::{Reader, RegisteredIo, UnixOps, registered},
test_runtime::{AbortingRuntime, TestRuntime, under_every_runtime},
},
};
#[test]
#[timeout(15000)]
fn a_call_that_waits_for_its_reply_fails_once_the_connection_stops() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = channel_pair(&runtime).await;
let conn = Connection::from(&stream);
let mut peer_stream = MessageStream::from(&peer);
let calling = conn.call_method(None::<()>, PATH, Some(INTERFACE), "NoReply", &());
let handing_over = async {
let call = peer_stream.next().await.unwrap().unwrap();
assert_eq!(call.header().member().unwrap().as_str(), "NoReply");
stream.hand_over().await.unwrap()
};
let (reply, _handover) = futures_util::future::join(calling, handing_over).await;
assert_not_connected(reply);
let late = conn
.call_method(None::<()>, PATH, Some(INTERFACE), "Late", &())
.await;
assert_not_connected(late);
assert_not_connected(MessageStream::for_match_rule(signals(), &conn, None).await);
});
}
#[test]
#[timeout(15000)]
fn a_connection_whose_peer_went_is_handed_over_with_what_it_sent() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = channel_pair(&runtime).await;
let conn = Connection::from(&stream);
let mut other = MessageStream::from(&conn);
let msg = signal(1);
peer.send(&msg).await.unwrap();
peer.close().await.unwrap();
let received = other.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msg.data()[..]);
assert_end_of_input(other.next().await.unwrap());
assert!(other.next().await.is_none(), "the stream outlived its end");
let call = conn
.call_method(None::<()>, PATH, Some(INTERFACE), "Late", &())
.await;
assert_end_of_input(call);
assert_broken_pipe(MessageStream::for_match_rule(signals(), &conn, None).await);
let handover = stream.hand_over().await.unwrap();
assert_eq!(handover.unread_len(), msg.data().len());
assert_eq!(unread(&handover), &msg.data()[..]);
assert!(
stream.next().await.is_none(),
"the stream outlived the hand-over"
);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msg.data()[..]);
assert_end_of_input(stream.next().await.unwrap());
assert!(stream.next().await.is_none(), "the stream outlived its end");
});
}
#[test]
#[timeout(15000)]
fn a_connection_whose_peer_closed_its_end_is_handed_over() {
under_every_runtime(|runtime| async move {
for (ended, record) in [(true, false), (false, false), (true, true), (false, true)] {
for (whole, cut) in [(true, 0), (true, 10), (false, 10), (false, 0)] {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let (last, next) = (signal(1), signal(2));
let mut sent = if whole { last.data().to_vec() } else { vec![] };
sent.extend_from_slice(&next.data()[..cut]);
(&peer).write_all(&sent).unwrap();
peer.shutdown(Shutdown::Write).unwrap();
if ended {
conn.closed().await;
}
let handover = stream.hand_over().await.unwrap();
let case =
format!("ended: {ended}, record: {record}, whole: {whole}, cut: {cut}");
assert!(stream.next().await.is_none(), "{case}");
assert!(
matches!(handover.socket, HandoverSocket::UnixStream(_)),
"{case}: a unix socket was handed over as {:?}",
handover.socket,
);
assert!(sent.starts_with(&unread(&handover)), "{case}");
let handover = if record {
through_a_record(handover, 5)
} else {
handover
};
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
if whole {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &last.data()[..], "{case}");
}
assert_end_of_input(stream.next().await.unwrap());
assert!(stream.next().await.is_none(), "{case}");
}
}
});
}
#[test]
#[timeout(15000)]
fn a_connection_whose_peer_went_is_handed_over_once_a_send_to_it_failed() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let last = signal(1);
(&peer).write_all(&last.data()[..]).unwrap();
drop(peer);
conn.closed().await;
assert_broken_pipe(conn.send(&signal(2)).await);
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), &last.data()[..]);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &last.data()[..]);
assert_end_of_input(stream.next().await.unwrap());
assert!(stream.next().await.is_none(), "the stream outlived its end");
});
}
#[cfg(any(target_os = "linux", target_os = "android"))]
#[test]
#[timeout(15000)]
fn a_connection_whose_peer_went_with_messages_unread_is_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let last = signal(1);
conn.send(&signal(2)).await.unwrap();
(&peer).write_all(&last.data()[..]).unwrap();
drop(peer);
conn.closed().await;
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), &last.data()[..]);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &last.data()[..]);
assert_end_of_input(stream.next().await.unwrap());
assert!(stream.next().await.is_none(), "the stream outlived its end");
});
}
#[test]
#[timeout(15000)]
fn a_connection_that_cant_stop_reading_reads_on() {
under_every_runtime(|runtime| async move {
let (peer, theirs) = UnixStream::pair().unwrap();
let split = recvmsg_only(&runtime, theirs, false);
let mut stream = on(
Builder::authenticated_socket(split, Guid::generate()),
&runtime,
)
.p2p()
.build_message_stream()
.await
.unwrap();
let conn = Connection::from(&stream);
let mut other = MessageStream::from(&conn);
let handed_over = stream.hand_over().await;
assert!(
matches!(handed_over, Err(Error::Unsupported)),
"{handed_over:?}"
);
let mut matching = MessageStream::for_match_rule(signals(), &conn, None)
.await
.unwrap();
let msg = signal(1);
(&peer).write_all(&msg.data()[..]).unwrap();
for stream in [&mut other, &mut matching] {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msg.data()[..]);
}
});
}
#[test]
#[timeout(15000)]
fn a_stream_for_a_match_rule_is_not_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = channel_pair(&runtime).await;
let conn = Connection::from(&stream);
let mut matching = MessageStream::for_match_rule(signals(), &conn, None)
.await
.unwrap();
let handed_over = matching.hand_over().await;
assert!(
matches!(handed_over, Err(Error::Unsupported)),
"{handed_over:?}"
);
let msg = signal(1);
peer.send(&msg).await.unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msg.data()[..]);
});
}
#[test]
#[timeout(15000)]
fn a_full_stream_is_handed_over_with_what_it_queued() {
under_every_runtime(|runtime| async move {
for taken in [0, 1] {
let (peer, theirs) = UnixStream::pair().unwrap();
let probe = theirs.try_clone().unwrap();
let socket = registered(&runtime, theirs, UnixOps).unwrap();
let mut stream = on(
Builder::authenticated_socket(socket, Guid::generate()),
&runtime,
)
.p2p()
.max_queued(NonZeroUsize::MIN)
.build_message_stream()
.await
.unwrap();
let conn = Connection::from(&stream);
let msgs = [1, 2, 3, 4].map(signal);
(&peer).write_all(&msgs[0].data()[..]).unwrap();
wait_until(|| conn.inner.msg_receiver.is_full());
let rest: Vec<u8> = msgs[1..]
.iter()
.flat_map(|msg| msg.data().to_vec())
.collect();
(&peer).write_all(&rest).unwrap();
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
for sent in &msgs[..taken] {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
}
let handover = stream.hand_over().await.unwrap();
let left: Vec<u8> = msgs[taken..]
.iter()
.flat_map(|msg| msg.data().to_vec())
.collect();
assert_eq!(unread(&handover), left, "taken: {taken}");
assert!(!handover.queued.is_empty(), "taken: {taken}");
peer.set_nonblocking(true).unwrap();
let read = (&peer).read(&mut [0; 1]);
assert!(
matches!(&read, Err(e) if e.kind() == ErrorKind::WouldBlock),
"the peer got something: {read:?}",
);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
for sent in &msgs[taken..] {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
}
}
});
}
#[test]
#[timeout(15000)]
fn messages_queued_on_the_stream_are_handed_over_with_their_descriptors() {
under_every_runtime(|runtime| async move {
for record in [false, true] {
let (mut stream, peer, probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let pipes = [pipe(), pipe(), pipe(), pipe()];
let fd = |i: usize| crate::Fd::from(&pipes[i]);
let msgs = [
Message::signal(PATH, INTERFACE, "WithFds")
.build(&fd(0))
.unwrap(),
Message::signal(PATH, INTERFACE, "WithFds")
.build(&(fd(1), fd(2)))
.unwrap(),
Message::signal(PATH, INTERFACE, "WithFds")
.build(&fd(3))
.unwrap(),
];
let fds: Vec<Vec<_>> = msgs
.iter()
.map(|msg| msg.data().fds().iter().map(AsFd::as_fd).collect())
.collect();
send_with_fds(&peer, &msgs[0].data()[..], &fds[0]);
send_with_fds(&peer, &msgs[1].data()[..], &fds[1]);
wait_until(|| conn.inner.msg_receiver.len() == 2);
send_with_fds(&peer, &msgs[2].data()[..20], &fds[2]);
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let handover = stream.hand_over().await.unwrap();
let sent = [
&msgs[0].data()[..],
&msgs[1].data()[..],
&msgs[2].data()[..20],
]
.concat();
assert_eq!(unread(&handover), sent, "record: {record}");
assert_eq!(handover.queued.len(), 2, "record: {record}");
assert_eq!(handover.tail, &msgs[2].data()[..20], "record: {record}");
assert_eq!(handover.fds().len(), 1 + pipes.len());
let inodes: Vec<_> = handover
.fds()
.into_iter()
.skip(1)
.map(|fd| inode(&fd))
.collect();
assert_eq!(inodes, pipes.each_ref().map(inode), "record: {record}");
drop(conn);
let handover = if record {
through_a_record(handover, 0)
} else {
handover
};
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
(&peer).write_all(&msgs[2].data()[20..]).unwrap();
for sent in &msgs {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
let inodes: Vec<_> = received.data().fds().iter().map(inode).collect();
let sent: Vec<_> = sent.data().fds().iter().map(inode).collect();
assert_eq!(inodes, sent, "record: {record}");
}
}
});
}
#[test]
#[timeout(15000)]
fn queued_messages_are_handed_over_as_they_are() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = channel_pair(&runtime).await;
let mut probe = stream.clone();
let msgs = [signal(1), signal(2)];
for msg in &msgs {
peer.send(msg).await.unwrap();
}
let queued = [
probe.next().await.unwrap().unwrap(),
probe.next().await.unwrap().unwrap(),
];
let handover = stream.hand_over().await.unwrap();
let bytes = |msg: &Message| msg.data().as_ptr();
assert_eq!(
handover.queued.iter().map(bytes).collect::<Vec<_>>(),
queued.iter().map(bytes).collect::<Vec<_>>(),
);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let received = [
stream.next().await.unwrap().unwrap(),
stream.next().await.unwrap().unwrap(),
];
assert_eq!(
received.iter().map(bytes).collect::<Vec<_>>(),
queued.iter().map(bytes).collect::<Vec<_>>(),
);
assert!(
received[0].recv_position() < received[1].recv_position(),
"{received:?}"
);
});
}
#[test]
#[timeout(15000)]
fn a_connection_that_took_over_hands_over_what_it_is_yet_to_yield() {
under_every_runtime(|runtime| async move {
let msgs = [1, 2, 3, 4].map(signal);
let tail = &msgs[3].data()[..10];
let (ours, peer) = UnixStream::pair().unwrap();
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
handover.queued = msgs[..3].to_vec();
handover.tail = tail.to_vec();
let mut stream = on(Builder::take_over(handover), &runtime)
.max_queued(NonZeroUsize::MIN)
.build_message_stream()
.await
.unwrap();
let conn = Connection::from(&stream);
wait_until(|| conn.inner.msg_receiver.is_full());
let handover = stream.hand_over().await.unwrap();
assert_eq!(handover.queued.len(), 3);
assert_eq!(
unread(&handover),
[concat(&msgs[..3]), tail.to_vec()].concat()
);
drop(conn);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
(&peer).write_all(&msgs[3].data()[10..]).unwrap();
for sent in &msgs {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
}
});
}
#[test]
#[timeout(15000)]
fn a_message_cut_short_is_handed_over() {
under_every_runtime(|runtime| async move {
hand_over_in_the_middle_of(&runtime, &signal(2), 10).await;
});
}
#[test]
#[timeout(15000)]
fn a_long_message_cut_short_is_handed_over() {
under_every_runtime(|runtime| async move {
let long = Message::signal(PATH, INTERFACE, "Long")
.build(&vec![7u8; 10 * 1024])
.unwrap();
let room = hand_over_in_the_middle_of(&runtime, &long, 6000).await;
assert_eq!(
room,
long.data().len(),
"the hand-over has no room for the rest of the message",
);
});
}
#[test]
#[timeout(15000)]
fn descriptors_that_came_in_are_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, probe) = served(&runtime).await;
let pipes = [pipe(), pipe()];
let msg = Message::signal(PATH, INTERFACE, "WithFds")
.build(&(crate::Fd::from(&pipes[0]), crate::Fd::from(&pipes[1])))
.unwrap();
let fds: Vec<_> = msg.data().fds().iter().map(AsFd::as_fd).collect();
send_with_fds(&peer, &msg.data()[..20], &fds);
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), &msg.data()[..20]);
let inodes: Vec<_> = handover
.fds()
.into_iter()
.skip(1)
.map(|fd| inode(&fd))
.collect();
assert_eq!(inodes, pipes.each_ref().map(inode));
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
(&peer).write_all(&msg.data()[20..]).unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msg.data()[..]);
let inodes: Vec<_> = received.data().fds().iter().map(inode).collect();
assert_eq!(inodes, pipes.each_ref().map(inode));
});
}
#[test]
#[timeout(15000)]
fn nothing_is_written_once_the_connection_is_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, probe) = served(&runtime).await;
drop(probe);
let conn = Connection::from(&stream);
let clone = conn.clone();
let handover = stream.hand_over().await.unwrap();
let msg = signal(1);
assert_not_connected(conn.send(&msg).await);
assert_not_connected(clone.send(&msg).await);
assert_not_connected(clone.send_all(&[msg]).await);
assert_not_connected(conn.flush().await);
conn.peer_creds().await.unwrap();
clone.close().await.unwrap();
peer.set_nonblocking(true).unwrap();
let read = (&peer).read(&mut [0; 1]);
assert!(
matches!(&read, Err(e) if e.kind() == ErrorKind::WouldBlock),
"the peer got {read:?}",
);
drop(handover);
let read = (&peer).read(&mut [0; 1]);
assert!(matches!(read, Ok(0)), "the peer got {read:?}");
});
}
#[test]
#[timeout(15000)]
fn a_tcp_stream_is_handed_over_as_one() {
under_every_runtime(|runtime| async move {
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).unwrap();
let ours = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
let theirs = listener.accept().unwrap().0;
let guid = Guid::generate();
let (mut stream, peer) = futures_util::try_join!(
on(Builder::tcp_stream(ours).p2p(), &runtime).build_message_stream(),
on(
Builder::tcp_stream(theirs)
.server(&guid)
.p2p()
.auth_mechanism(AuthMechanism::Anonymous),
&runtime,
)
.build(),
)
.unwrap();
let handover = stream.hand_over().await.unwrap();
assert_eq!(saved(&handover).0[24], TCP_STREAM);
match handover.socket {
HandoverSocket::TcpStream(socket) => carries_what_is_sent(socket, &peer).await,
socket => panic!("a TCP socket was handed over as {socket:?}"),
}
});
}
#[test]
#[timeout(15000)]
fn a_connection_to_a_unix_address_is_handed_over_as_a_unix_stream() {
under_every_runtime(|runtime| async move {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("socket");
let listener = UnixListener::bind(&path).unwrap();
listener.set_nonblocking(true).unwrap();
let address = Address::from(Transport::Unix(Unix::new(UnixSocket::File(path))));
let guid = Guid::generate();
let serving = async {
let theirs = loop {
match listener.accept() {
Ok((theirs, _)) => break theirs,
Err(e) if e.kind() == ErrorKind::WouldBlock => {
runtime.sleep(Duration::from_millis(1)).await;
}
Err(e) => panic!("the listener failed: {e}"),
}
};
on(Builder::unix_stream(theirs).server(&guid).p2p(), &runtime)
.build()
.await
};
let (mut stream, peer) = futures_util::try_join!(
on(Builder::address(address).p2p(), &runtime).build_message_stream(),
serving,
)
.unwrap();
let handover = stream.hand_over().await.unwrap();
assert_eq!(saved(&handover).0[24], UNIX_STREAM);
match handover.socket {
HandoverSocket::UnixStream(socket) => carries_what_is_sent(socket, &peer).await,
socket => panic!("a unix socket was handed over as {socket:?}"),
}
});
}
#[test]
#[timeout(15000)]
fn a_send_cut_off_midway_keeps_the_connection_from_being_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = over_a_socket_pair_of_your_own(&runtime).await;
let conn = Connection::from(&stream);
let big = big_signal();
{
let sending = pin!(conn.send(&big));
stuck(&runtime, sending, &peer).await;
}
let handed_over = stream.hand_over().await;
let Err(Error::InputOutput(e)) = &handed_over else {
panic!("a connection with a torn send was handed over: {handed_over:?}");
};
assert_eq!(e.kind(), ErrorKind::InvalidData, "{e}");
assert!(
!conn.is_closed(),
"the refused hand-over closed the connection"
);
let reading = MessageStream::for_match_rule(signals(), &conn, None).await;
assert!(
reading.is_ok(),
"the connection stopped reading: {reading:?}"
);
let sent = futures_lite::future::poll_once(pin!(conn.send(&signal(1)))).await;
assert!(
!matches!(sent, Some(Err(_))),
"the send was refused: {sent:?}"
);
conn.clone().close().await.unwrap();
let mut received = vec![];
(&peer).read_to_end(&mut received).unwrap();
assert!(received.len() < big.data().len());
});
}
#[test]
#[timeout(15000)]
fn a_hand_over_given_up_on_goes_on_through_its_stream() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = over_a_socket_pair_of_your_own(&runtime).await;
let conn = Connection::from(&stream);
let queued = queue_two(&conn, &peer);
let big = big_signal();
let mut sending = pin!(conn.send(&big));
stuck(&runtime, sending.as_mut(), &peer).await;
let given_up = runtime
.timeout(stream.hand_over(), Duration::from_millis(100))
.await;
let Err(Error::InputOutput(e)) = &given_up else {
panic!("the hand-over didn't wait for the send: {given_up:?}");
};
assert_eq!(e.kind(), ErrorKind::TimedOut, "{e}");
assert!(
!conn.is_closed(),
"the given up hand-over closed the connection"
);
let late = conn
.call_method(None::<()>, PATH, Some(INTERFACE), "Late", &())
.await;
assert_not_connected(late);
assert_not_connected(MessageStream::for_match_rule(signals(), &conn, None).await);
assert_not_connected(MessageStream::from(&conn).hand_over().await);
let len = big.data().len();
let reading = thread::spawn(move || {
let mut received = vec![0; len];
(&peer).read_exact(&mut received).unwrap();
(received, peer)
});
sending.await.unwrap();
let (received, peer) = reading.join().unwrap();
assert_eq!(received, &big.data()[..]);
let msg = signal(3);
conn.send(&msg).await.unwrap();
let mut received = vec![0; msg.data().len()];
(&peer).read_exact(&mut received).unwrap();
assert_eq!(received, &msg.data()[..]);
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), queued);
assert!(
stream.next().await.is_none(),
"the stream outlived the hand-over"
);
});
}
#[test]
#[timeout(15000)]
fn a_failed_hand_over_leaves_the_messages_on_its_stream() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = over_a_socket_pair_of_your_own(&runtime).await;
let conn = Connection::from(&stream);
let queued = queue_two(&conn, &peer);
let big = big_signal();
let mut sending = Box::pin(conn.send(&big));
stuck(&runtime, sending.as_mut(), &peer).await;
let cutting = async { drop(sending) };
let (handed_over, ()) = futures_util::future::join(stream.hand_over(), cutting).await;
let Err(Error::InputOutput(e)) = &handed_over else {
panic!("a connection with a torn send was handed over: {handed_over:?}");
};
assert_eq!(e.kind(), ErrorKind::InvalidData, "{e}");
let mut received = vec![];
while let Some(msg) = stream.next().await {
received.extend_from_slice(&msg.unwrap().data()[..]);
}
assert_eq!(received, queued);
});
}
#[test]
#[timeout(15000)]
fn a_send_cut_off_midway_as_the_peer_goes_fails_no_hand_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = over_a_socket_pair_of_your_own(&runtime).await;
let conn = Connection::from(&stream);
let queued = queue_two(&conn, &peer);
let big = big_signal();
let mut sending = pin!(conn.send(&big));
stuck(&runtime, sending.as_mut(), &peer).await;
let mut handing_over = pin!(stream.hand_over());
let waiting = futures_lite::future::poll_once(handing_over.as_mut()).await;
assert!(waiting.is_none(), "the hand-over didn't wait for the send");
wait_until(|| !conn.inner.socket_status.stop.reading());
drop(peer);
let (handed_over, sent) = futures_util::future::join(handing_over, sending).await;
let Err(Error::InputOutput(e)) = &sent else {
panic!("the send went through: {sent:?}");
};
assert!(
matches!(e.kind(), ErrorKind::BrokenPipe | ErrorKind::ConnectionReset),
"{e}"
);
assert_eq!(unread(&handed_over.unwrap()), queued);
});
}
#[test]
#[timeout(15000)]
fn the_rest_of_a_send_cut_off_midway_is_handed_over() {
under_every_runtime(|runtime| async move {
for record in [false, true] {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let (big, next) = (big_signal(), signal(1));
stuck(&runtime, pin!(conn.send(&big)), &peer).await;
let unwritten = conn.unwritten_len();
assert!(unwritten > 0, "the send left nothing to write");
let handover = stream.hand_over().await.unwrap();
assert_eq!(handover.unwritten_len(), unwritten, "record: {record}");
assert_eq!(conn.unwritten_len(), 0);
let handover = if record {
through_a_record(handover, 2)
} else {
handover
};
let conn = on(Builder::take_over(handover), &runtime)
.build()
.await
.unwrap();
assert_eq!(conn.unwritten_len(), unwritten, "record: {record}");
let reading = read_in_the_background(&peer, big.data().len() + next.data().len());
conn.send(&next).await.unwrap();
let received = reading.join().unwrap();
assert_eq!(received, [&big.data()[..], &next.data()[..]].concat());
assert_eq!(conn.unwritten_len(), 0);
}
});
}
#[test]
#[timeout(15000)]
fn a_send_that_waits_for_the_peer_holds_no_hand_over_up() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let msgs = [big_signal(), signal(1)];
let mut sending = pin!(conn.send_all(&msgs));
stuck(&runtime, sending.as_mut(), &peer).await;
let (handed_over, sent) = futures_util::future::join(stream.hand_over(), sending).await;
sent.unwrap();
let handover = handed_over.unwrap();
let [big, after] = &msgs;
let unwritten = handover.unwritten_len();
assert!(
after.data().len() < unwritten && unwritten < big.data().len() + after.data().len(),
"{unwritten} bytes left to write",
);
let conn = on(Builder::take_over(handover), &runtime)
.build()
.await
.unwrap();
let reading = read_in_the_background(&peer, concat(&msgs).len());
conn.flush().await.unwrap();
assert_eq!(reading.join().unwrap(), concat(&msgs));
});
}
#[test]
#[timeout(15000)]
fn a_flush_under_way_holds_the_hand_over_up() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let big = big_signal();
stuck(&runtime, pin!(conn.send(&big)), &peer).await;
let mut flushing = pin!(conn.flush());
let flushed = futures_lite::future::poll_once(flushing.as_mut()).await;
assert!(flushed.is_none(), "the flush didn't wait for the peer");
let given_up = runtime
.timeout(stream.hand_over(), Duration::from_millis(100))
.await;
let Err(Error::InputOutput(e)) = &given_up else {
panic!("the hand-over didn't wait for the flush: {given_up:?}");
};
assert_eq!(e.kind(), ErrorKind::TimedOut, "{e}");
let reading = read_in_the_background(&peer, big.data().len());
flushing.await.unwrap();
assert_eq!(reading.join().unwrap(), &big.data()[..]);
let handover = stream.hand_over().await.unwrap();
assert_eq!(handover.unwritten_len(), 0);
});
}
#[test]
#[timeout(15000)]
fn messages_left_to_write_are_handed_over_with_their_descriptors() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, _probe) = served(&runtime).await;
let conn = Connection::from(&stream);
let pipes = [pipe(), pipe(), pipe()];
let with = |i: usize| {
Message::signal(PATH, INTERFACE, "WithFd")
.build(&crate::Fd::from(&pipes[i]))
.unwrap()
};
let received = with(0);
send_with_fds(&peer, &received.data()[..], &[pipes[0].as_fd()]);
wait_until(|| conn.inner.msg_receiver.len() == 1);
assert!(conn.prepare_hand_over());
let kept = [big_signal(), with(1), with(2)];
conn.send_all(&kept).await.unwrap();
let handover = stream.hand_over().await.unwrap();
assert!(handover.unwritten_len() > concat(&kept[1..]).len());
let inodes: Vec<_> = handover
.fds()
.into_iter()
.skip(1)
.map(|fd| inode(&fd))
.collect();
assert_eq!(inodes, pipes.each_ref().map(inode));
drop(conn);
let handover = through_a_record(handover, 6);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let conn = Connection::from(&stream);
let msg = stream.next().await.unwrap().unwrap();
assert_eq!(&msg.data()[..], &received.data()[..]);
let mut peer = Reader::new(Arc::new(registered(&runtime, peer, UnixOps).unwrap()));
let receiving = async {
let mut msgs = vec![];
for seq in 0..kept.len() {
let msg = peer
.receive_message(seq as u64, &mut vec![], &mut vec![])
.await;
msgs.push(msg.unwrap());
}
msgs
};
let (flushed, msgs) = futures_util::future::join(conn.flush(), receiving).await;
flushed.unwrap();
for (msg, sent) in msgs.iter().zip(&kept) {
assert_eq!(&msg.data()[..], &sent.data()[..]);
let inodes: Vec<_> = msg.data().fds().iter().map(inode).collect();
let sent: Vec<_> = sent.data().fds().iter().map(inode).collect();
assert_eq!(inodes, sent);
}
});
}
#[test]
#[timeout(15000)]
fn a_closed_connection_is_not_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, _peer) = channel_pair(&runtime).await;
Connection::from(&stream).close().await.unwrap();
assert_not_connected(stream.hand_over().await);
});
}
#[test]
#[timeout(15000)]
fn a_connection_closed_over_a_socket_is_not_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, _peer) = over_a_socket_pair(&runtime).await;
let conn = Connection::from(&stream);
conn.clone().close().await.unwrap();
wait_until(|| !conn.inner.socket_status.stop.reading());
{
let end = conn.inner.socket_status.stop.reader_end.lock().unwrap();
assert!(matches!(*end, ReaderEnd::Ended(_)), "the reader {end:?}");
}
assert_not_connected(stream.hand_over().await);
});
}
#[test]
#[timeout(15000)]
fn a_connection_whose_reader_was_taken_away_is_not_handed_over() {
let runtime = AbortingRuntime::new();
let (ours, theirs) = Channel::pair();
futures_lite::future::block_on(async {
let guid = Guid::generate();
let (mut stream, _peer) = futures_util::try_join!(
Builder::authenticated_socket(ours, guid.clone())
.p2p()
.runtime(runtime.clone())
.build_message_stream(),
Builder::authenticated_socket(theirs, guid)
.p2p()
.runtime(TestRuntime::new())
.build(),
)
.unwrap();
runtime.abort_tasks();
Connection::from(&stream).closed().await;
assert_not_connected(stream.hand_over().await);
});
}
#[test]
#[timeout(15000)]
fn a_connection_is_handed_over_once() {
under_every_runtime(|runtime| async move {
let (mut stream, _peer) = channel_pair(&runtime).await;
let conn = Connection::from(&stream);
let mut other = MessageStream::from(&conn);
let handovers = futures_util::future::join(stream.hand_over(), other.hand_over()).await;
let (handover, refused) = match handovers {
(Ok(handover), refused) | (refused, Ok(handover)) => (handover, refused),
handovers => panic!("the connection wasn't handed over: {handovers:?}"),
};
assert_eq!(handover.saved_len(), None, "{handover:?}");
assert_not_connected(refused);
let credentials = conn.peer_creds().await;
assert!(
matches!(&credentials, Err(e) if e.kind() == io::ErrorKind::NotConnected),
"{credentials:?}",
);
});
}
#[test]
#[timeout(15000)]
fn a_channel_is_handed_over_with_the_messages_that_it_is_yet_to_read() {
under_every_runtime(|runtime| async move {
for taken in [0, 7, 50] {
let (mut stream, peer) = channel_pair(&runtime).await;
let msgs: Vec<_> = (0..50).map(signal).collect();
let sending = async {
for msg in &msgs {
peer.send(msg).await.unwrap();
}
};
let receiving = async {
let mut received = vec![];
for _ in 0..taken {
received.push(stream.next().await.unwrap().unwrap());
}
let handover = stream.hand_over().await.unwrap();
assert_eq!(handover.saved_len(), None, "{handover:?}");
assert_eq!(handover.fds().len(), 0);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
while received.len() < msgs.len() {
received.push(stream.next().await.unwrap().unwrap());
}
received
};
let ((), received) = futures_util::future::join(sending, receiving).await;
let numbers: Vec<u32> = received
.iter()
.map(|msg| msg.body().deserialize().unwrap())
.collect();
assert_eq!(numbers, (0..50).collect::<Vec<_>>(), "taken: {taken}");
}
});
}
#[test]
#[timeout(15000)]
fn messages_after_a_take_over_are_ordered_after_those_handed_over() {
under_every_runtime(|runtime| async move {
let (mut stream, peer) = channel_pair(&runtime).await;
let mut probe = stream.clone();
let [handed, live] = ["Handed", "Live"]
.map(|member| Message::signal(PATH, INTERFACE, member).build(&()).unwrap());
peer.send(&handed).await.unwrap();
probe.next().await.unwrap().unwrap();
let handover = stream.hand_over().await.unwrap();
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let only = |member: &'static str| {
let is_member = move |msg: &Result<Message>| {
msg.as_ref()
.is_ok_and(|msg| msg.header().member().unwrap().as_str() == member)
};
ordered_stream::OrderedStreamExt::filter(stream.clone(), is_member)
};
let joined = ordered_stream::join(only("Handed"), only("Live"));
peer.send(&live).await.unwrap();
let received = [
stream.next().await.unwrap().unwrap(),
stream.next().await.unwrap().unwrap(),
];
assert_eq!(members(&received), ["Handed", "Live"]);
assert!(
received[0].recv_position() < received[1].recv_position(),
"{received:?}"
);
let joined: Vec<_> = ordered_stream::OrderedStreamExt::into_stream(joined)
.take(2)
.map(Result::unwrap)
.collect()
.await;
assert_eq!(members(&joined), ["Handed", "Live"]);
});
}
#[test]
#[timeout(15000)]
fn a_connection_over_halves_of_your_own_is_taken_over() {
under_every_runtime(|runtime| async move {
let (peer, theirs) = UnixStream::pair().unwrap();
let probe = theirs.try_clone().unwrap();
let split = recvmsg_only(&runtime, theirs, true);
let mut stream = on(
Builder::authenticated_socket(split, Guid::generate()),
&runtime,
)
.p2p()
.build_message_stream()
.await
.unwrap();
let msgs = [1, 2, 3].map(signal);
let mut sent = msgs[0].data().to_vec();
sent.extend_from_slice(&msgs[1].data()[..10]);
(&peer).write_all(&sent).unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &msgs[0].data()[..]);
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), &msgs[1].data()[..10]);
assert_eq!(handover.saved_len(), None, "{handover:?}");
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
let mut rest = msgs[1].data()[10..].to_vec();
rest.extend_from_slice(&msgs[2].data()[..]);
(&peer).write_all(&rest).unwrap();
for sent in &msgs[1..] {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
}
});
}
#[test]
#[timeout(15000)]
fn a_bus_connection_isnt_taken_over_as_a_peer_to_peer_one() {
under_every_runtime(|runtime| async move {
let (ours, _theirs) = Channel::pair();
let handover = handover(HandoverSocket::Socket(ours.into()), false);
let built = on(Builder::take_over(handover), &runtime)
.p2p()
.build()
.await;
assert!(matches!(built, Err(Error::Unsupported)), "{built:?}");
});
}
#[test]
#[timeout(15000)]
fn serial_numbers_go_on_from_that_of_the_hand_over() {
under_every_runtime(|runtime| async move {
let floor = next_serial().checked_add(1000).unwrap();
for next in [floor, NonZeroU32::MIN] {
let (ours, _theirs) = Channel::pair();
let mut handover = handover(HandoverSocket::Socket(ours.into()), true);
handover.next_serial = next;
let _conn = on(Builder::take_over(handover), &runtime)
.build()
.await
.unwrap();
let serial = signal(1).primary_header().serial_num();
assert!(serial >= floor, "{serial} is below {floor}");
}
});
}
#[test]
#[timeout(15000)]
fn a_bus_connection_takes_over_with_its_unique_name() {
under_every_runtime(|runtime| async move {
for record in [false, true] {
let (mut bus_stream, ours) = over_a_socket_pair(&runtime).await;
let handover = handover(HandoverSocket::UnixStream(ours), false);
let handover = if record {
through_a_record(handover, 1)
} else {
handover
};
let conn = on(Builder::take_over(handover), &runtime)
.build()
.await
.unwrap();
assert!(
conn.is_bus(),
"a bus connection was taken over as a peer-to-peer one"
);
assert_eq!(conn.unique_name().unwrap().as_str(), UNIQUE_NAME);
conn.emit_signal(None::<()>, PATH, INTERFACE, "Test", &())
.await
.unwrap();
let msg = bus_stream.next().await.unwrap().unwrap();
assert_eq!(msg.message_type(), Type::Signal);
assert_eq!(msg.header().sender().unwrap(), UNIQUE_NAME);
}
});
}
#[cfg(feature = "service")]
#[test]
#[timeout(15000)]
fn a_bus_connection_that_took_over_serves_calls_to_its_unique_name() {
under_every_runtime(|runtime| async move {
let (bus, ours) = over_a_socket_pair(&runtime).await;
let bus = Connection::from(&bus);
let _conn = on(
Builder::take_over(handover(HandoverSocket::UnixStream(ours), false)),
&runtime,
)
.serve_at(PATH, Echo)
.build()
.await
.unwrap();
let reply = bus
.call_method(Some(UNIQUE_NAME), PATH, Some(INTERFACE), "Echo", &"hello")
.await
.unwrap();
assert_eq!(reply.body().deserialize::<String>().unwrap(), "hello");
});
}
#[cfg(feature = "service")]
#[test]
#[timeout(15000)]
fn a_method_call_left_unread_is_served_once_taken_over() {
under_every_runtime(|runtime| async move {
for queued in [true, false] {
let (mut peer_stream, ours) = over_a_socket_pair(&runtime).await;
let call = Message::method_call(PATH, "Echo")
.interface(INTERFACE)
.build(&"left unread")
.unwrap();
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
if queued {
handover.queued = vec![call.clone()];
} else {
handover.tail = call.data().to_vec();
}
let _conn = on(Builder::take_over(handover), &runtime)
.serve_at(PATH, Echo)
.build()
.await
.unwrap();
let reply = peer_stream.next().await.unwrap().unwrap();
assert_eq!(reply.message_type(), Type::MethodReturn, "queued: {queued}");
assert_eq!(
reply.header().reply_serial(),
Some(call.primary_header().serial_num()),
);
assert_eq!(reply.body().deserialize::<&str>().unwrap(), "left unread");
}
});
}
#[cfg(feature = "bus-impl")]
#[test]
#[timeout(15000)]
fn the_bodies_of_messages_left_unread_are_checked() {
under_every_runtime(|runtime| async move {
for queued in [true, false] {
let (_peer, ours) = UnixStream::pair().unwrap();
let builder = Message::signal(PATH, INTERFACE, "Test");
let invalid =
unsafe { builder.build_raw_body(&[2, 0, 0, 0], "b", vec![]) }.unwrap();
let valid = signal(1);
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
if queued {
handover.queued = vec![valid.clone(), invalid];
} else {
handover.tail = concat(&[valid.clone(), invalid]);
}
let mut stream = on(Builder::take_over(handover).validate_bodies(), &runtime)
.build_message_stream()
.await
.unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &valid.data()[..], "queued: {queued}");
let error = stream.next().await.unwrap().unwrap_err();
assert!(matches!(error, Error::Failure(_)), "{error:?}");
assert!(
stream.next().await.is_none(),
"the stream outlived its error"
);
}
});
}
#[test]
#[timeout(15000)]
fn what_was_left_unwritten_is_written_ahead_of_the_first_send() {
under_every_runtime(|runtime| async move {
for (record, flush) in [(false, false), (false, true), (true, false), (true, true)] {
let case = format!("record: {record}, flush: {flush}");
let (ours, peer) = UnixStream::pair().unwrap();
let (cut, next) = (signal(1), signal(4));
let kept = [with_fd(2), signal(3)];
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
handover.unix_fd_passing = true;
handover.unwritten = Unwritten {
cut: Some((cut.data().clone(), 10)),
kept: kept.iter().cloned().collect(),
};
let unwritten = cut.data().len() - 10 + concat(&kept).len();
assert_eq!(handover.unwritten.len(), unwritten);
let handover = if record {
through_a_record(handover, 7)
} else {
handover
};
let conn = on(Builder::take_over(handover), &runtime)
.build()
.await
.unwrap();
assert_eq!(conn.unwritten_len(), unwritten, "{case}");
assert_nothing_to_read(&peer);
if flush {
conn.flush().await.unwrap();
} else {
conn.send(&next).await.unwrap();
}
assert_eq!(conn.unwritten_len(), 0, "{case}");
let mut peer = Reader::new(Arc::new(registered(&runtime, peer, UnixOps).unwrap()));
let mut start = cut.data()[..10].to_vec();
let mut sent = vec![&cut];
sent.extend(&kept);
if !flush {
sent.push(&next);
}
for (seq, sent) in sent.into_iter().enumerate() {
let received = peer
.receive_message(seq as u64, &mut start, &mut vec![])
.await
.unwrap();
assert_eq!(&received.data()[..], &sent.data()[..], "{case}");
assert_eq!(
received.data().fds().len(),
sent.data().fds().len(),
"{case}"
);
}
}
});
}
#[test]
#[timeout(15000)]
fn a_hand_over_goes_through_its_record() {
under_every_runtime(|runtime| async move {
let (mut stream, peer, probe) = served(&runtime).await;
let pipes = [pipe(), pipe()];
let msgs = [
Message::signal(PATH, INTERFACE, "WithFds")
.build(&crate::Fd::from(&pipes[0]))
.unwrap(),
Message::signal(PATH, INTERFACE, "WithFds")
.build(&crate::Fd::from(&pipes[1]))
.unwrap(),
];
send_with_fds(&peer, &msgs[0].data()[..], &[pipes[0].as_fd()]);
send_with_fds(&peer, &msgs[1].data()[..20], &[pipes[1].as_fd()]);
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let mut handover = stream.hand_over().await.unwrap();
handover.unique_name = Some(UNIQUE_NAME.try_into().unwrap());
let left = unread(&handover);
let next_serial = handover.next_serial;
let guid = handover.server_guid.clone();
let handover = through_a_record(handover, 3);
assert!(
matches!(handover.socket, HandoverSocket::UnixStream(_)),
"a unix socket was restored as {:?}",
handover.socket,
);
assert_eq!(handover.server_guid, guid);
assert_eq!(handover.unique_name.as_ref().unwrap().as_str(), UNIQUE_NAME);
assert_eq!(unread(&handover), left);
let inodes: Vec<_> = handover
.fds()
.into_iter()
.skip(1)
.map(|fd| inode(&fd))
.collect();
assert_eq!(inodes, pipes.each_ref().map(inode));
assert!(handover.unix_fd_passing);
assert!(handover.p2p);
assert_eq!(handover.next_serial, next_serial);
let mut stream = on(Builder::take_over(handover), &runtime)
.build_message_stream()
.await
.unwrap();
assert_eq!(
Connection::from(&stream).unique_name().unwrap().as_str(),
UNIQUE_NAME
);
(&peer).write_all(&msgs[1].data()[20..]).unwrap();
for (sent, pipe) in msgs.iter().zip(&pipes) {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
let inodes: Vec<_> = received.data().fds().iter().map(inode).collect();
assert_eq!(inodes, [inode(pipe)]);
}
});
}
#[test]
fn a_tcp_hand_over_goes_through_its_record() {
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).unwrap();
let socket = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
let address = socket.local_addr().unwrap();
let mut handover = handover(HandoverSocket::TcpStream(socket), false);
handover.unique_name = None;
handover.next_serial = NonZeroU32::new(77).unwrap();
let guid = handover.server_guid.clone();
let handover = through_a_record(handover, 0);
match &handover.socket {
HandoverSocket::TcpStream(socket) => assert_eq!(socket.local_addr().unwrap(), address),
socket => panic!("a TCP socket was restored as {socket:?}"),
}
assert_eq!(handover.fds().len(), 1);
assert_eq!(handover.server_guid, guid);
assert!(handover.unique_name.is_none());
assert_eq!(handover.unread_len(), 0);
assert_eq!(handover.unwritten_len(), 0);
assert!(!handover.unix_fd_passing);
assert!(!handover.p2p);
assert_eq!(handover.next_serial.get(), 77);
}
#[test]
fn a_record_restores_from_anywhere_in_memory() {
let (handover, _peer) = every_part();
let (record, _fds) = saved(&handover);
assert_eq!(record.len() % 8, 0, "{} bytes of record", record.len());
let inodes: Vec<_> = handover.fds().into_iter().map(|fd| inode(&fd)).collect();
let mut handover = handover;
for at in [1, 2, 3, 4, 5, 6, 7, 8, 13] {
handover = through_a_record(handover, at);
assert_eq!(saved(&handover).0, record, "at {at}");
let restored: Vec<_> = handover.fds().into_iter().map(|fd| inode(&fd)).collect();
assert_eq!(restored, inodes, "at {at}");
}
assert_eq!(handover.queued.len(), 2);
assert_eq!(handover.tail.len(), 10);
assert_eq!(handover.unwritten.rest().len(), 15);
assert_eq!(handover.unwritten.kept.len(), 2);
}
#[test]
fn a_record_of_a_later_format_is_refused() {
for (at, value) in [(8, &(MAJOR + 1).to_le_bytes()[..]), (12, &[1][..])] {
let (record, fds) =
changed(|record| record[at..at + value.len()].copy_from_slice(value));
let restored = Handover::restore(&record, fds);
assert!(matches!(restored, Err(Error::Unsupported)), "{restored:?}");
}
let (record, fds) = changed(|record| record[8..10].copy_from_slice(&[0, 0]));
assert_invalid_data(Handover::restore(&record, fds));
}
#[test]
fn a_record_with_more_in_its_header_is_restored() {
let (handover, _peer) = every_part();
let (record, fds) = saved(&handover);
let header_len = usize::from(u16::from_le_bytes([record[10], record[11]]));
let mut later = record[..header_len].to_vec();
later.extend_from_slice(b"12345678");
later.extend_from_slice(&record[header_len..]);
later[10..12].copy_from_slice(&(header_len as u16 + 8).to_le_bytes());
later[16..24].copy_from_slice(&(record.len() as u64 + 8).to_le_bytes());
later[25] |= 0x80;
later[27] = 0xff;
let restored = Handover::restore(&later, fds).unwrap();
assert_eq!(saved(&restored).0, record);
}
#[test]
fn what_is_not_a_record_is_refused() {
let (handover, _peer) = every_part();
let (record, _) = saved(&handover);
let header_len = usize::from(u16::from_le_bytes([record[10], record[11]]));
let inbound = header_len + 4 * 8;
let refused = |what: &str, (record, fds): (Vec<u8>, Vec<OwnedFd>)| {
let restored = Handover::restore(&record, fds);
let Err(Error::InputOutput(e)) = &restored else {
panic!("a record with a wrong {what} was restored: {restored:?}");
};
assert_eq!(e.kind(), ErrorKind::InvalidData, "{what}: {e}");
};
let fields: [(&str, usize, &[u8]); 15] = [
("magic", 0, b"zbus-hoW"),
("odd header", 10, &(header_len as u16 - 4).to_le_bytes()),
("short header", 10, &(NAME as u16).to_le_bytes()),
("record length", 16, &1u64.to_le_bytes()),
("kind", 24, &[2]),
("serial", 28, &0u32.to_le_bytes()),
("descriptors", 32, &99u32.to_le_bytes()),
("tail descriptors", 40, &0u32.to_le_bytes()),
("inbound length", 48, &8u64.to_le_bytes()),
("rest length", 64, &u64::MAX.to_le_bytes()),
("GUID", 72, b"not hex!"),
("unique name", NAME, b"org"),
("message length", header_len, &17u32.to_le_bytes()),
("message descriptors", header_len + 4, &0u32.to_le_bytes()),
("message", inbound, b"X"),
];
for (what, at, value) in fields {
refused(
what,
changed(|record| record[at..at + value.len()].copy_from_slice(value)),
);
}
let lengths: [(&str, Change); 5] = [
("padding", |record| *record.last_mut().unwrap() = 1),
("length, as longer", |record| {
record.extend_from_slice(&[0; 8])
}),
("length, as shorter", |record| {
record.truncate(record.len() - 8)
}),
("length, as a header only", |record| record.truncate(NAME)),
("length, as nothing", Vec::clear),
];
for (what, change) in lengths {
refused(what, changed(change));
}
let (record, mut fds) = changed(|_| ());
fds.push(pipe());
assert_invalid_data(Handover::restore(&record, fds));
let (record, mut fds) = changed(|_| ());
fds.pop();
assert_invalid_data(Handover::restore(&record, fds));
}
#[test]
fn a_record_is_saved_only_into_memory_exactly_as_long_as_it() {
let (handover, _peer) = every_part();
let len = handover.saved_len().unwrap();
for len in [len - 1, len + 1, 0] {
let mut memory = vec![0xa5; len];
let saved = handover.save(&mut memory);
let Err(e) = &saved else {
panic!("a record was saved into {len} bytes: {saved:?}");
};
assert_eq!(e.kind(), ErrorKind::InvalidInput, "{e}");
assert!(
memory.iter().all(|byte| *byte == 0xa5),
"the save wrote some"
);
}
}
#[test]
fn a_socket_of_your_own_has_no_record() {
let (ours, _theirs) = Channel::pair();
let mut handover = handover(HandoverSocket::Socket(ours.into()), true);
handover.queued = vec![with_fd(1)];
let saved = handover.save(&mut []);
let Err(e) = saved else {
panic!("a record of a socket of your own was saved");
};
assert_eq!(e.kind(), ErrorKind::Unsupported, "{e}");
assert_eq!(handover.saved_len(), None);
assert!(handover.fds().is_empty());
}
#[test]
fn a_hand_over_shows_how_much_it_holds() {
fn sendable<T>(_: &T)
where
T: Send + Sync,
{
}
let (ours, _theirs) = UnixStream::pair().unwrap();
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
handover.tail = vec![b'#'; 10 * 1024];
let shown = format!("{handover:?}");
assert!(shown.contains("unread_len: 10240"), "{shown}");
assert!(!shown.contains("35, 35"), "{shown}");
sendable(&handover);
}
async fn hand_over_in_the_middle_of(runtime: &Runtime, cut: &Message, at: usize) -> usize {
let (mut stream, peer, probe) = served(runtime).await;
let conn = Connection::from(&stream);
let (whole, last) = (signal(1), signal(3));
let mut sent = whole.data().to_vec();
sent.extend_from_slice(&cut.data()[..at]);
(&peer).write_all(&sent).unwrap();
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &whole.data()[..]);
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let handover = stream.hand_over().await.unwrap();
assert!(
conn.is_closed(),
"the connection is open after its hand-over"
);
assert_eq!(unread(&handover), &cut.data()[..at]);
assert!(handover.queued.is_empty());
assert_eq!(handover.fds().len(), 1);
assert_eq!(&handover.server_guid, conn.server_guid());
assert_eq!(handover.unique_name.as_ref(), conn.unique_name());
assert!(handover.unix_fd_passing);
assert!(handover.p2p);
assert!(handover.next_serial > last.primary_header().serial_num());
assert!(
matches!(handover.socket, HandoverSocket::UnixStream(_)),
"a unix socket was handed over as {:?}",
handover.socket,
);
let room = handover.tail.capacity();
let guid = handover.server_guid.clone();
drop(conn);
let mut stream = on(Builder::take_over(handover), runtime)
.build_message_stream()
.await
.unwrap();
let conn = Connection::from(&stream);
assert_eq!(conn.server_guid(), &guid);
assert!(
conn.inner.cap_unix_fd,
"the connection that took over can't pass file descriptors",
);
let mut rest = cut.data()[at..].to_vec();
rest.extend_from_slice(&last.data()[..]);
(&peer).write_all(&rest).unwrap();
for sent in [cut, &last] {
let received = stream.next().await.unwrap().unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
}
(&peer).write_all(&cut.data()[..at]).unwrap();
wait_until(|| rustix::io::ioctl_fionread(&probe).unwrap() == 0);
let handover = stream.hand_over().await.unwrap();
assert_eq!(unread(&handover), &cut.data()[..at]);
assert!(
matches!(handover.socket, HandoverSocket::UnixStream(_)),
"a unix socket was handed over again as {:?}",
handover.socket,
);
room
}
fn recvmsg_only(runtime: &Runtime, socket: UnixStream, can_take_unread: bool) -> BoxedSplit {
let socket = Arc::new(registered(runtime, socket, UnixOps).unwrap());
let read = RecvmsgOnly {
socket: socket.clone(),
can_take_unread,
};
Split::new(Box::new(read), Box::new(socket) as Box<dyn WriteHalf>)
}
#[derive(Debug)]
struct RecvmsgOnly {
socket: Arc<RegisteredIo<UnixOps>>,
can_take_unread: bool,
}
#[async_trait::async_trait]
impl ReadHalf for RecvmsgOnly {
async fn recvmsg(&mut self, buffer: &mut [u8]) -> RecvmsgResult {
self.socket.recv(buffer).await
}
fn can_take_unread(&self) -> bool {
self.can_take_unread
}
}
async fn served(runtime: &Runtime) -> (MessageStream, UnixStream, UnixStream) {
let (client, server) = UnixStream::pair().unwrap();
let probe = server.try_clone().unwrap();
let id = hex::encode(rustix::process::geteuid().as_raw().to_string());
let commands = format!("\0AUTH EXTERNAL {id}\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n");
(&client).write_all(commands.as_bytes()).unwrap();
let guid = Guid::generate();
let stream = on(Builder::unix_stream(server).server(&guid).p2p(), runtime)
.build_message_stream()
.await
.unwrap();
let answer = format!("OK {guid}\r\nAGREE_UNIX_FD\r\n");
let mut answered = vec![0; answer.len()];
(&client).read_exact(&mut answered).unwrap();
assert_eq!(answered, answer.as_bytes());
(stream, client, probe)
}
async fn over_a_socket_pair(runtime: &Runtime) -> (MessageStream, UnixStream) {
let (peer, theirs) = UnixStream::pair().unwrap();
let socket = registered(runtime, theirs, UnixOps).unwrap();
let stream = on(
Builder::authenticated_socket(socket, Guid::generate()),
runtime,
)
.p2p()
.build_message_stream()
.await
.unwrap();
(stream, peer)
}
async fn over_a_socket_pair_of_your_own(runtime: &Runtime) -> (MessageStream, UnixStream) {
let (peer, theirs) = UnixStream::pair().unwrap();
let socket = Arc::new(registered(runtime, theirs, UnixOps).unwrap());
let split = Split::new(
Box::new(Reader::new(socket.clone())) as Box<dyn ReadHalf>,
Box::new(SendmsgOnly(socket)) as Box<dyn WriteHalf>,
);
let stream = on(
Builder::authenticated_socket(split, Guid::generate()),
runtime,
)
.p2p()
.build_message_stream()
.await
.unwrap();
(stream, peer)
}
#[derive(Debug)]
struct SendmsgOnly(Arc<RegisteredIo<UnixOps>>);
#[async_trait::async_trait]
impl WriteHalf for SendmsgOnly {
async fn sendmsg(&mut self, buffer: &[u8], fds: &[BorrowedFd<'_>]) -> io::Result<usize> {
WriteHalf::sendmsg(&mut self.0, buffer, fds).await
}
async fn close(&mut self) -> io::Result<()> {
WriteHalf::close(&mut self.0).await
}
fn can_pass_unix_fd(&self) -> bool {
true
}
}
fn queue_two(conn: &Connection, peer: &UnixStream) -> Vec<u8> {
let queued: Vec<u8> = [signal(1), signal(2)]
.iter()
.flat_map(|msg| msg.data().to_vec())
.collect();
(&*peer).write_all(&queued).unwrap();
wait_until(|| conn.inner.msg_receiver.len() == 2);
queued
}
fn handover(socket: HandoverSocket, p2p: bool) -> Handover {
Handover {
socket,
server_guid: Guid::generate().into(),
unique_name: (!p2p).then(|| UNIQUE_NAME.try_into().unwrap()),
unix_fd_passing: false,
p2p,
next_serial: NonZeroU32::MIN,
queued: vec![],
tail: vec![],
tail_fds: vec![],
unwritten: Unwritten::default(),
}
}
fn every_part() -> (Handover, UnixStream) {
let (ours, theirs) = UnixStream::pair().unwrap();
let mut handover = handover(HandoverSocket::UnixStream(ours), true);
handover.unique_name = Some(UNIQUE_NAME.try_into().unwrap());
handover.unix_fd_passing = true;
handover.next_serial = NonZeroU32::new(42).unwrap();
handover.queued = vec![with_fd(1), signal(2)];
handover.tail = with_fd(3).data()[..10].to_vec();
handover.tail_fds = vec![pipe()];
let cut = signal(4);
let written = cut.data().len() - 15;
handover.unwritten = Unwritten {
cut: Some((cut.data().clone(), written)),
kept: VecDeque::from([with_fd(5), signal(6)]),
};
(handover, theirs)
}
fn through_a_record(handover: Handover, at: usize) -> Handover {
let len = handover
.saved_len()
.expect("the hand-over of a socket that zbus drives");
assert_eq!(len % 8, 0, "{len} bytes of record");
let mut memory = vec![0xa5; at + len + 7];
handover.save(&mut memory[at..][..len]).unwrap();
let fds = duplicates(&handover);
drop(handover);
Handover::restore(&memory[at..][..len], fds).unwrap()
}
fn saved(handover: &Handover) -> (Vec<u8>, Vec<OwnedFd>) {
let mut record = vec![0; handover.saved_len().unwrap()];
handover.save(&mut record).unwrap();
(record, duplicates(handover))
}
fn changed(change: impl Fn(&mut Vec<u8>)) -> (Vec<u8>, Vec<OwnedFd>) {
let (handover, _peer) = every_part();
let (mut record, fds) = saved(&handover);
change(&mut record);
(record, fds)
}
type Change = fn(&mut Vec<u8>);
fn duplicates(handover: &Handover) -> Vec<OwnedFd> {
handover
.fds()
.into_iter()
.map(|fd| fd.try_clone_to_owned().unwrap())
.collect()
}
fn unread(handover: &Handover) -> Vec<u8> {
[concat(&handover.queued), handover.tail.clone()].concat()
}
fn concat(msgs: &[Message]) -> Vec<u8> {
msgs.iter().flat_map(|msg| msg.data().to_vec()).collect()
}
fn read_in_the_background(peer: &UnixStream, len: usize) -> thread::JoinHandle<Vec<u8>> {
let peer = peer.try_clone().unwrap();
thread::spawn(move || {
let mut received = vec![0; len];
(&peer).read_exact(&mut received).unwrap();
received
})
}
fn assert_nothing_to_read(peer: &UnixStream) {
peer.set_nonblocking(true).unwrap();
let read = (&*peer).read(&mut [0; 1]);
assert!(
matches!(&read, Err(e) if e.kind() == ErrorKind::WouldBlock),
"the peer got {read:?}",
);
}
async fn stuck<F>(runtime: &Runtime, mut sending: Pin<&mut F>, peer: &UnixStream)
where
F: Future<Output = Result<()>>,
{
while rustix::io::ioctl_fionread(peer).unwrap() == 0 {
let sent = futures_lite::future::poll_once(sending.as_mut()).await;
assert!(
sent.is_none(),
"the socket took the whole message: {sent:?}"
);
runtime.sleep(Duration::from_millis(1)).await;
}
}
fn send_with_fds(socket: &UnixStream, bytes: &[u8], fds: &[BorrowedFd<'_>]) {
use rustix::net::{SendAncillaryBuffer, SendAncillaryMessage, SendFlags, sendmsg};
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(2))];
let mut ancillary = SendAncillaryBuffer::new(&mut space);
assert!(ancillary.push(SendAncillaryMessage::ScmRights(fds)));
let sent = sendmsg(
socket,
&[IoSlice::new(bytes)],
&mut ancillary,
SendFlags::empty(),
)
.unwrap();
assert_eq!(sent, bytes.len());
}
fn pipe() -> OwnedFd {
io::pipe().unwrap().0.into()
}
fn inode(fd: &impl AsFd) -> u64 {
use std::os::unix::fs::MetadataExt;
std::fs::File::from(fd.as_fd().try_clone_to_owned().unwrap())
.metadata()
.unwrap()
.ino()
}
async fn carries_what_is_sent<S>(socket: S, peer: &Connection)
where
S: AsFd,
for<'s> &'s S: Read,
{
let read = (&socket).read(&mut [0; 1]);
assert!(
matches!(&read, Err(e) if e.kind() == ErrorKind::WouldBlock),
"the read didn't find the socket empty: {read:?}",
);
let msg = signal(1);
peer.send(&msg).await.unwrap();
rustix::io::ioctl_fionbio(&socket, false).unwrap();
let mut received = vec![0; msg.data().len()];
(&socket).read_exact(&mut received).unwrap();
assert_eq!(received, &msg.data()[..]);
}
async fn channel_pair(runtime: &Runtime) -> (MessageStream, Connection) {
let guid = Guid::generate();
let (ours, theirs) = Channel::pair();
futures_util::try_join!(
on(Builder::authenticated_socket(ours, guid.clone()), runtime)
.p2p()
.build_message_stream(),
on(Builder::authenticated_socket(theirs, guid), runtime)
.p2p()
.build(),
)
.unwrap()
}
fn on<'a>(builder: Builder<'a>, runtime: &Runtime) -> Builder<'a> {
match runtime {
#[cfg(feature = "default-rt")]
Runtime::ZRuntime(_) => builder,
#[cfg(feature = "tokio")]
Runtime::Tokio(_) => builder,
Runtime::External(runtime) => builder.runtime(runtime.clone()),
}
}
fn assert_not_connected<T: Debug>(result: Result<T>) {
let Err(Error::InputOutput(e)) = &result else {
panic!("expected the error of a connection that is not connected: {result:?}");
};
assert_eq!(e.kind(), io::ErrorKind::NotConnected, "{e}");
}
fn assert_broken_pipe<T: Debug>(result: Result<T>) {
let Err(Error::InputOutput(e)) = &result else {
panic!("expected the error of a broken pipe: {result:?}");
};
assert_eq!(e.kind(), io::ErrorKind::BrokenPipe, "{e}");
}
fn assert_end_of_input<T: Debug>(result: Result<T>) {
let Err(Error::InputOutput(e)) = &result else {
panic!("expected the error of the end of the input: {result:?}");
};
assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof, "{e}");
}
fn assert_invalid_data<T: Debug>(result: Result<T>) {
let Err(Error::InputOutput(e)) = &result else {
panic!("expected the error of what is not a record: {result:?}");
};
assert_eq!(e.kind(), io::ErrorKind::InvalidData, "{e}");
}
fn signals() -> MatchRule<'static> {
MatchRule::builder().msg_type(Type::Signal).build().unwrap()
}
fn signal(n: u32) -> Message {
Message::signal(PATH, INTERFACE, "Test").build(&n).unwrap()
}
fn with_fd(n: u32) -> Message {
Message::signal(PATH, INTERFACE, "WithFd")
.build(&(n, crate::Fd::from(&pipe())))
.unwrap()
}
fn members(msgs: &[Message]) -> Vec<String> {
msgs.iter()
.map(|msg| msg.header().member().unwrap().to_string())
.collect()
}
fn big_signal() -> Message {
Message::signal(PATH, INTERFACE, "Big")
.build(&vec![0u8; 1024 * 1024])
.unwrap()
}
fn wait_until(mut condition: impl FnMut() -> bool) {
while !condition() {
thread::sleep(Duration::from_millis(1));
}
}
#[cfg(all(unix, feature = "service"))]
struct Echo;
#[cfg(all(unix, feature = "service"))]
#[crate::interface(name = "org.zbus.Test")]
impl Echo {
fn echo(&self, text: String) -> String {
text
}
}
const PATH: &str = "/org/zbus/Test";
const INTERFACE: &str = "org.zbus.Test";
const UNIQUE_NAME: &str = ":1.42";
}
#[cfg(all(test, not(feature = "p2p")))]
mod tests_without_p2p {
use std::{
num::NonZeroU32,
os::{fd::OwnedFd, unix::net::UnixStream},
};
use zoter::{Restore, Save};
use super::{Handover, HandoverSocket, P2P};
use crate::{Error, Guid, OwnedGuid, connection::socket_write::Unwritten};
#[test]
fn a_bus_hand_over_goes_through_its_record() {
let handover = bus_handover();
let guid = handover.server_guid.clone();
let (record, fds) = saved(&handover);
drop(handover);
let handover = Handover::restore(&record, fds).unwrap();
assert!(
matches!(handover.socket, HandoverSocket::UnixStream(_)),
"a unix socket was restored as {:?}",
handover.socket,
);
assert_eq!(handover.server_guid, guid);
assert_eq!(handover.unique_name.unwrap().as_str(), ":1.42");
assert_eq!(handover.tail, [1, 2, 3]);
assert!(handover.tail_fds.is_empty());
assert!(handover.unix_fd_passing);
assert_eq!(handover.next_serial.get(), 77);
}
#[test]
fn a_peer_to_peer_record_is_not_restored() {
let (mut record, fds) = saved(&bus_handover());
record[25] |= P2P;
let restored = Handover::restore(&record, fds);
assert!(matches!(restored, Err(Error::Unsupported)), "{restored:?}");
}
fn bus_handover() -> Handover {
let (ours, _theirs) = UnixStream::pair().unwrap();
Handover {
socket: HandoverSocket::UnixStream(ours),
server_guid: guid(),
unique_name: Some(":1.42".try_into().unwrap()),
unix_fd_passing: true,
next_serial: NonZeroU32::new(77).unwrap(),
queued: vec![],
tail: vec![1, 2, 3],
tail_fds: vec![],
unwritten: Unwritten::default(),
}
}
fn saved(handover: &Handover) -> (Vec<u8>, Vec<OwnedFd>) {
let mut record = vec![0; handover.saved_len().unwrap()];
handover.save(&mut record).unwrap();
let fds = handover
.fds()
.into_iter()
.map(|fd| fd.try_clone_to_owned().unwrap())
.collect();
(record, fds)
}
fn guid() -> OwnedGuid {
Guid::from_static_str("0123456789abcdef0123456789abcdef")
.unwrap()
.into()
}
}