#[cfg(feature = "p2p")]
pub mod channel;
#[cfg(feature = "p2p")]
pub use channel::Channel;
mod split;
pub(crate) use split::Writes;
pub use split::{BoxedSplit, Split};
use std::{io, mem};
#[cfg(unix)]
use crate::utils::FDS_MAX;
use crate::{
Message,
conn::AuthMechanism,
fdo::ConnectionCredentials,
log::trace,
message::{
PrimaryHeader,
header::{MAX_MESSAGE_SIZE, MIN_MESSAGE_SIZE},
},
padding_for_8_bytes,
wire::{
Endian,
serialized::{self, Context},
},
};
#[cfg(unix)]
use std::os::fd::{AsFd, BorrowedFd, OwnedFd};
#[cfg(unix)]
pub(crate) type RecvmsgResult = io::Result<(usize, Vec<OwnedFd>)>;
#[cfg(not(unix))]
pub(crate) type RecvmsgResult = io::Result<usize>;
pub trait Socket {
type ReadHalf: ReadHalf;
type WriteHalf: WriteHalf;
fn split(self) -> Split<Self::ReadHalf, Self::WriteHalf>
where
Self: Sized;
}
#[async_trait::async_trait]
pub trait ReadHalf: std::fmt::Debug + Send + Sync + 'static {
async fn receive_message(
&mut self,
seq: u64,
already_received_bytes: &mut Vec<u8>,
#[cfg(unix)] already_received_fds: &mut Vec<OwnedFd>,
) -> crate::Result<Message> {
let (primary_header, len) = loop {
let have = already_received_bytes.len();
let want = if have < MIN_MESSAGE_SIZE {
MIN_MESSAGE_SIZE
} else {
let (primary_header, len) = read_primary_header(already_received_bytes)?;
if have >= len {
break (primary_header, len);
}
len
};
already_received_bytes.reserve_exact(want - have);
let mut room = Room::new(already_received_bytes, want.min(have + READ_MAX));
let received = self.recvmsg(room.unfilled()).await;
#[cfg(unix)]
let (read, fds) = received?;
#[cfg(not(unix))]
let read = received?;
if read == 0 {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"failed to receive message",
)
.into());
}
room.filled(read);
#[cfg(unix)]
{
already_received_fds.extend(fds);
if already_received_fds.len() > FDS_MAX {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"too many file descriptors that no header counts",
)
.into());
}
}
};
take_message(
seq,
&primary_header,
len,
already_received_bytes,
#[cfg(unix)]
already_received_fds,
)
}
async fn recvmsg(&mut self, _buf: &mut [u8]) -> RecvmsgResult {
unimplemented!("`ReadHalf` implementers must either override `read_message` or `recvmsg`");
}
fn can_pass_unix_fd(&self) -> bool {
false
}
async fn peer_credentials(&mut self) -> io::Result<ConnectionCredentials> {
Ok(ConnectionCredentials::default())
}
fn auth_mechanism(&self) -> AuthMechanism {
AuthMechanism::External
}
#[cfg(all(target_os = "linux", feature = "handover"))]
fn can_take_unread(&self) -> bool {
false
}
#[cfg(all(target_os = "linux", feature = "handover"))]
fn take_unread(&mut self, bytes: &mut Vec<u8>, fds: &mut Vec<OwnedFd>) {
let _ = (bytes, fds);
}
}
#[async_trait::async_trait]
pub trait WriteHalf: std::fmt::Debug + Send + Sync + 'static {
async fn send_message(&mut self, msg: &Message) -> crate::Result<()> {
let data = msg.data();
let serial = msg.primary_header().serial_num();
trace!("Sending message: {:?}", msg);
let mut pos = 0;
while pos < data.len() {
#[cfg(unix)]
let fds = if pos == 0 {
data.fds().iter().map(|f| f.as_fd()).collect()
} else {
vec![]
};
pos += self
.sendmsg(
&data[pos..],
#[cfg(unix)]
&fds,
)
.await?;
}
self.flush().await?;
trace!("Sent message with serial: {}", serial);
Ok(())
}
async fn send_messages(&mut self, msgs: &[Message]) -> crate::Result<()> {
for msg in msgs {
self.send_message(msg).await?;
}
Ok(())
}
async fn sendmsg(
&mut self,
_buffer: &[u8],
#[cfg(unix)] _fds: &[BorrowedFd<'_>],
) -> io::Result<usize> {
unimplemented!("`WriteHalf` implementers must either override `send_message` or `sendmsg`");
}
async fn flush(&mut self) -> io::Result<()> {
Ok(())
}
#[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
async fn send_zero_byte(&mut self) -> io::Result<Option<usize>> {
Ok(None)
}
async fn close(&mut self) -> io::Result<()>;
fn can_pass_unix_fd(&self) -> bool {
false
}
async fn peer_credentials(&mut self) -> io::Result<ConnectionCredentials> {
Ok(ConnectionCredentials::default())
}
fn can_resume_writes(&self) -> bool {
false
}
}
pub(crate) fn read_primary_header(bytes: &[u8]) -> crate::Result<(PrimaryHeader, usize)> {
let (primary_header, fields_len) = PrimaryHeader::read(bytes)?;
let header_len = MIN_MESSAGE_SIZE + fields_len as usize;
let body_padding = padding_for_8_bytes(header_len);
let body_len = primary_header.body_len() as usize;
let total_len = header_len + body_padding + body_len;
if total_len > MAX_MESSAGE_SIZE {
return Err(crate::Error::ExcessData);
}
Ok((primary_header, total_len))
}
pub(crate) fn take_message(
seq: u64,
primary_header: &PrimaryHeader,
len: usize,
bytes: &mut Vec<u8>,
#[cfg(unix)] fds: &mut Vec<OwnedFd>,
) -> crate::Result<Message> {
let rest = bytes.split_off(len);
let bytes = mem::replace(bytes, rest);
#[cfg(unix)]
let fds = if fds.is_empty() {
vec![]
} else {
let (_, _, fields) = crate::message::parser::parse(&bytes)?;
let count = (fields.unix_fds().unwrap_or(0) as usize).min(fds.len());
fds.drain(..count).collect()
};
let endian = Endian::from(primary_header.endian_sig());
let ctxt = Context::new(endian, 0);
#[cfg(unix)]
let bytes = serialized::Data::new_fds(bytes, ctxt, fds);
#[cfg(not(unix))]
let bytes = serialized::Data::new(bytes, ctxt);
Message::from_raw_parts(bytes, seq)
}
const READ_MAX: usize = 64 * 1024;
struct Room<'b> {
bytes: &'b mut Vec<u8>,
keep: usize,
}
impl<'b> Room<'b> {
fn new(bytes: &'b mut Vec<u8>, len: usize) -> Self {
let keep = bytes.len();
bytes.resize(len, 0);
Self { bytes, keep }
}
fn unfilled(&mut self) -> &mut [u8] {
&mut self.bytes[self.keep..]
}
fn filled(&mut self, len: usize) {
self.keep += len;
}
}
impl Drop for Room<'_> {
fn drop(&mut self) {
self.bytes.truncate(self.keep);
}
}
#[async_trait::async_trait]
impl ReadHalf for Box<dyn ReadHalf> {
fn can_pass_unix_fd(&self) -> bool {
(**self).can_pass_unix_fd()
}
async fn receive_message(
&mut self,
seq: u64,
already_received_bytes: &mut Vec<u8>,
#[cfg(unix)] already_received_fds: &mut Vec<OwnedFd>,
) -> crate::Result<Message> {
(**self)
.receive_message(
seq,
already_received_bytes,
#[cfg(unix)]
already_received_fds,
)
.await
}
async fn recvmsg(&mut self, buf: &mut [u8]) -> RecvmsgResult {
(**self).recvmsg(buf).await
}
async fn peer_credentials(&mut self) -> io::Result<ConnectionCredentials> {
(**self).peer_credentials().await
}
fn auth_mechanism(&self) -> AuthMechanism {
(**self).auth_mechanism()
}
#[cfg(all(target_os = "linux", feature = "handover"))]
fn can_take_unread(&self) -> bool {
(**self).can_take_unread()
}
#[cfg(all(target_os = "linux", feature = "handover"))]
fn take_unread(&mut self, bytes: &mut Vec<u8>, fds: &mut Vec<OwnedFd>) {
(**self).take_unread(bytes, fds)
}
}
#[async_trait::async_trait]
impl WriteHalf for Box<dyn WriteHalf> {
async fn send_message(&mut self, msg: &Message) -> crate::Result<()> {
(**self).send_message(msg).await
}
async fn send_messages(&mut self, msgs: &[Message]) -> crate::Result<()> {
(**self).send_messages(msgs).await
}
async fn sendmsg(
&mut self,
buffer: &[u8],
#[cfg(unix)] fds: &[BorrowedFd<'_>],
) -> io::Result<usize> {
(**self)
.sendmsg(
buffer,
#[cfg(unix)]
fds,
)
.await
}
async fn flush(&mut self) -> io::Result<()> {
(**self).flush().await
}
#[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
async fn send_zero_byte(&mut self) -> io::Result<Option<usize>> {
(**self).send_zero_byte().await
}
async fn close(&mut self) -> io::Result<()> {
(**self).close().await
}
fn can_pass_unix_fd(&self) -> bool {
(**self).can_pass_unix_fd()
}
async fn peer_credentials(&mut self) -> io::Result<ConnectionCredentials> {
(**self).peer_credentials().await
}
fn can_resume_writes(&self) -> bool {
(**self).can_resume_writes()
}
}
#[cfg(test)]
mod tests {
use std::collections::VecDeque;
#[cfg(unix)]
use std::os::unix::fs::MetadataExt;
use futures_lite::future::{block_on, poll_once};
use ntest::timeout;
use test_log::test;
use super::*;
#[cfg(unix)]
use crate::{Error, Fd};
#[test]
#[timeout(15000)]
fn messages_come_out_whole_from_calls_dropped_while_they_wait() {
let msgs = [
Message::method_call("/", "Ping")
.interface("org.freedesktop.DBus.Peer")
.build(&())
.unwrap(),
Message::signal("/", "org.zbus.Test", "Signal")
.build(&"a string")
.unwrap(),
Message::method_call("/", "Test")
.build(&vec![7u8; 100])
.unwrap(),
Message::method_call("/", "Test")
.build(&(1u32, "more"))
.unwrap(),
];
let next = Message::method_call("/", "Test")
.build(&vec![8u8; 100])
.unwrap();
let partial = &next.data()[..20];
let written = [
msgs.iter().flat_map(|msg| msg.data().to_vec()).collect(),
partial.to_vec(),
]
.concat();
let mut bytes = written[..msgs[0].data().len() + 5].to_vec();
let mut reads = pieces(&written[bytes.len()..], &[1, 2, 3]);
let mut half = Scripted::default();
#[cfg(unix)]
let mut fds = vec![];
let mut received = vec![];
while received.len() < msgs.len() {
let polled = half.receive(
&mut bytes,
#[cfg(unix)]
&mut fds,
);
match polled {
Some(msg) => received.push(msg.unwrap()),
None => half.push(reads.pop_front().expect("a call waits with all of it read")),
}
}
half.reads.extend(reads.into_iter().map(Read::from));
let polled = half.receive(
&mut bytes,
#[cfg(unix)]
&mut fds,
);
assert!(polled.is_none(), "a message came out of part of one");
assert!(half.reads.is_empty(), "a call left reads alone");
for (received, sent) in received.iter().zip(&msgs) {
assert_eq!(&received.data()[..], &sent.data()[..]);
}
assert_eq!(bytes, partial);
}
#[test]
#[timeout(15000)]
fn a_long_message_comes_out_whole_in_reads_of_no_more_than_read_max() {
let msg = Message::method_call("/", "Test")
.build(&vec![7u8; 3 * READ_MAX + READ_MAX / 2])
.unwrap();
let mut reads = pieces(
&msg.data()[..],
&[READ_MAX - 1, READ_MAX + 1, 2 * READ_MAX + 3],
);
let mut half = Scripted::default();
let mut bytes = vec![];
#[cfg(unix)]
let mut fds = vec![];
let received = loop {
let polled = half.receive(
&mut bytes,
#[cfg(unix)]
&mut fds,
);
match polled {
Some(received) => break received.unwrap(),
None => half.push(reads.pop_front().expect("a call waits with all of it read")),
}
};
assert_eq!(&received.data()[..], &msg.data()[..]);
assert!(bytes.is_empty(), "bytes were left over");
assert_eq!(half.largest_room, READ_MAX);
}
#[cfg(unix)]
#[test]
#[timeout(15000)]
fn messages_take_as_many_fds_as_their_headers_count() {
let pipes = [(); 4].map(|()| pipe());
let inodes = pipes.each_ref().map(inode);
let fd = |i: usize| Fd::from(pipes[i].as_fd());
let msgs = [
Message::method_call("/", "Test")
.build(&(0u32, fd(0)))
.unwrap(),
Message::method_call("/", "Test")
.build(&(1u32, fd(1), fd(2)))
.unwrap(),
Message::method_call("/", "Test").build(&2u32).unwrap(),
Message::method_call("/", "Test")
.build(&(3u32, fd(3)))
.unwrap(),
];
let (start, body) = msgs[3].data().split_at(20);
let mut half = Scripted::default();
half.push_with_fds(msgs[0].data()[..1].to_vec(), clones(&pipes[..3]));
half.push(
[
&msgs[0].data()[1..],
&msgs[1].data()[..],
&msgs[2].data()[..],
start,
]
.concat(),
);
half.push_with_fds(body.to_vec(), clones(&pipes[3..]));
let (mut bytes, mut fds) = (vec![], vec![]);
let mut received_with = vec![];
for sent in &msgs {
let received = half
.receive(&mut bytes, &mut fds)
.expect("a call waits with the message read")
.unwrap();
assert_eq!(&received.data()[..], &sent.data()[..]);
let fds = received.data().fds().iter().map(inode);
received_with.push(
fds.map(|inode| inodes.iter().position(|i| *i == inode).unwrap())
.collect::<Vec<_>>(),
);
}
assert_eq!(
received_with,
[&[0][..], &[1, 2], &[], &[3]],
"the descriptors went with other messages than their own",
);
assert!(fds.is_empty(), "descriptors were left over");
}
#[cfg(unix)]
#[test]
#[timeout(15000)]
fn a_message_with_fewer_fds_than_its_header_counts_is_an_error() {
let pipes = [pipe(), pipe()];
let msg = Message::method_call("/", "Test")
.build(&(Fd::from(pipes[0].as_fd()), Fd::from(pipes[1].as_fd())))
.unwrap();
let mut half = Scripted::default();
half.push(msg.data().to_vec());
let mut fds = clones(&pipes[..1]);
let received = half
.receive(&mut vec![], &mut fds)
.expect("a call waits with the message read");
assert!(
matches!(received, Err(Error::MissingParameter(_))),
"{received:?}",
);
}
#[cfg(unix)]
#[test]
#[timeout(15000)]
fn more_than_fds_max_waiting_fds_are_an_error() {
allow_open_fds(2 * FDS_MAX as u64);
let pipe = pipe();
let msg = Message::method_call("/", "Test").build(&()).unwrap();
let mut half = Scripted::default();
let extra = (0..FDS_MAX).map(|_| pipe.try_clone().unwrap()).collect();
half.push_with_fds(msg.data().to_vec(), extra);
half.push_with_fds(msg.data().to_vec(), clones(&[pipe]));
let (mut bytes, mut fds) = (vec![], vec![]);
let first = half
.receive(&mut bytes, &mut fds)
.expect("a call waits with the message read");
let second = half
.receive(&mut bytes, &mut fds)
.expect("a call waits with the message read");
assert_eq!(&first.unwrap().data()[..], &msg.data()[..]);
assert!(
matches!(&second, Err(Error::InputOutput(e)) if e.kind() == io::ErrorKind::InvalidData),
"{second:?}",
);
}
#[derive(Debug, Default)]
struct Scripted {
reads: VecDeque<Read>,
largest_room: usize,
}
impl Scripted {
fn receive(
&mut self,
bytes: &mut Vec<u8>,
#[cfg(unix)] fds: &mut Vec<OwnedFd>,
) -> Option<crate::Result<Message>> {
let call = self.receive_message(
0,
bytes,
#[cfg(unix)]
fds,
);
block_on(poll_once(call))
}
fn push(&mut self, bytes: Vec<u8>) {
self.reads.push_back(Read::from(bytes));
}
#[cfg(unix)]
fn push_with_fds(&mut self, bytes: Vec<u8>, fds: Vec<OwnedFd>) {
self.reads.push_back(Read { bytes, fds });
}
}
#[async_trait::async_trait]
impl ReadHalf for Scripted {
async fn recvmsg(&mut self, buffer: &mut [u8]) -> RecvmsgResult {
self.largest_room = self.largest_room.max(buffer.len());
let Some(mut read) = self.reads.pop_front() else {
return std::future::pending().await;
};
let len = read.bytes.len().min(buffer.len());
buffer[..len].copy_from_slice(&read.bytes[..len]);
if len < read.bytes.len() {
self.reads.push_front(Read::from(read.bytes.split_off(len)));
}
#[cfg(unix)]
let received = (len, read.fds);
#[cfg(not(unix))]
let received = len;
Ok(received)
}
}
#[derive(Debug)]
struct Read {
bytes: Vec<u8>,
#[cfg(unix)]
fds: Vec<OwnedFd>,
}
impl From<Vec<u8>> for Read {
fn from(bytes: Vec<u8>) -> Self {
Self {
bytes,
#[cfg(unix)]
fds: vec![],
}
}
}
fn pieces(mut bytes: &[u8], sizes: &[usize]) -> VecDeque<Vec<u8>> {
let mut sizes = sizes.iter().cycle();
let mut pieces = VecDeque::new();
while !bytes.is_empty() {
let (piece, rest) = bytes.split_at((*sizes.next().unwrap()).min(bytes.len()));
pieces.push_back(piece.to_vec());
bytes = rest;
}
pieces
}
#[cfg(unix)]
fn pipe() -> OwnedFd {
std::io::pipe().unwrap().0.into()
}
#[cfg(unix)]
fn clones(fds: &[OwnedFd]) -> Vec<OwnedFd> {
fds.iter().map(|fd| fd.try_clone().unwrap()).collect()
}
#[cfg(unix)]
fn inode(fd: &impl AsFd) -> u64 {
std::fs::File::from(fd.as_fd().try_clone_to_owned().unwrap())
.metadata()
.unwrap()
.ino()
}
#[cfg(unix)]
fn allow_open_fds(count: u64) {
use rustix::process::{Resource, getrlimit, setrlimit};
let mut limit = getrlimit(Resource::Nofile);
if limit.current.is_some_and(|current| current < count) {
limit.current = Some(count);
setrlimit(Resource::Nofile, limit).expect("too low a hard limit on open descriptors");
}
}
}