use std::io::{self, IoSlice, IoSliceMut};
use std::mem::MaybeUninit;
use std::os::fd::{AsFd, OwnedFd};
use std::os::unix::net::UnixDatagram;
use std::process::{Child, Stdio};
use rustix::net::{
self, RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, SendAncillaryBuffer,
SendAncillaryMessage, SendFlags,
};
use super::super::{
Activity, Descriptor, SharedAudio,
doorbell::Doorbell,
errors::{TRANSFER, invalid},
realtime::{Ring, RingDescriptor},
};
const ACTIVITY_TAG: u64 = 0;
const CHANNEL_TAG: u64 = u64::MAX;
pub struct Sender {
socket: UnixDatagram,
}
pub struct Receiver {
socket: UnixDatagram,
}
impl Sender {
pub fn new() -> io::Result<(Self, Stdio)> {
let (socket, child) = UnixDatagram::pair()?;
Ok((Self { socket }, Stdio::from(OwnedFd::from(child))))
}
pub fn send(&self, memory: &SharedAudio, _child: &Child) -> io::Result<u64> {
self.send_fd(memory.memory.handle(), memory.descriptor.generation)
}
pub fn send_activity(&self, activity: &Activity, _child: &Child) -> io::Result<u64> {
self.send_fd(activity.memory.handle(), ACTIVITY_TAG)
}
pub fn send_channel(&self, channel: &OwnedFd, _child: &Child) -> io::Result<u64> {
self.send_fd(channel, CHANNEL_TAG)
}
pub fn send_ring(&self, ring: &Ring, _child: &Child) -> io::Result<Vec<u64>> {
let descriptor = ring.descriptor();
let mut tokens = vec![self.send_fd(ring.control_memory().handle(), descriptor.control)?];
for lane in ring.lane_audio() {
tokens.push(self.send_fd(lane.memory.handle(), lane.descriptor.generation)?);
}
Ok(tokens)
}
fn send_fd(&self, fd: &OwnedFd, tag: u64) -> io::Result<u64> {
let payload = tag.to_le_bytes();
let fds = [fd.as_fd()];
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
let mut control = SendAncillaryBuffer::new(&mut space);
if !control.push(SendAncillaryMessage::ScmRights(&fds)) {
return Err(invalid(TRANSFER));
}
let sent = net::sendmsg(
&self.socket,
&[IoSlice::new(&payload)],
&mut control,
SendFlags::DONTWAIT,
)?;
if sent != payload.len() {
return Err(invalid(TRANSFER));
}
Ok(tag)
}
}
impl Receiver {
pub fn take_from_stdin() -> io::Result<Self> {
let fd = io::stdin().as_fd().try_clone_to_owned()?;
rustix::stdio::dup2_stdin(std::fs::File::open("/dev/null")?)?;
Ok(Self {
socket: UnixDatagram::from(fd),
})
}
pub unsafe fn receive(&self, descriptor: Descriptor, token: u64) -> io::Result<SharedAudio> {
if token != descriptor.generation {
return Err(invalid(TRANSFER));
}
unsafe { SharedAudio::open(self.receive_fd(token)?, descriptor) }
}
pub unsafe fn receive_activity(&self, token: u64) -> io::Result<Activity> {
if token != ACTIVITY_TAG {
return Err(invalid(TRANSFER));
}
unsafe { Activity::open(self.receive_fd(token)?) }
}
pub fn receive_channel(&self, token: u64) -> io::Result<OwnedFd> {
if token != CHANNEL_TAG {
return Err(invalid(TRANSFER));
}
self.receive_fd(token)
}
pub unsafe fn receive_ring(
&self,
descriptor: RingDescriptor,
tokens: &[u64],
) -> io::Result<Ring> {
let [control, lanes @ ..] = tokens else {
return Err(invalid(TRANSFER));
};
if *control != descriptor.control
|| lanes.len() != descriptor.lanes
|| lanes
.iter()
.enumerate()
.any(|(index, &token)| token != descriptor.first_lane + index as u64)
{
return Err(invalid(TRANSFER));
}
let control = self.receive_fd(*control)?;
let lanes = lanes
.iter()
.map(|&token| self.receive_fd(token))
.collect::<io::Result<_>>()?;
unsafe { Ring::open(descriptor, control, lanes, Doorbell::new()?) }
}
fn receive_fd(&self, tag: u64) -> io::Result<OwnedFd> {
let mut payload = [0; 8];
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
let mut control = RecvAncillaryBuffer::new(&mut space);
let received = net::recvmsg(
&self.socket,
&mut [IoSliceMut::new(&mut payload)],
&mut control,
RecvFlags::DONTWAIT,
)?;
let mut received_fd = None;
for message in control.drain() {
if let RecvAncillaryMessage::ScmRights(fds) = message {
for fd in fds {
if received_fd.is_some() {
return Err(invalid(TRANSFER));
}
rustix::io::fcntl_setfd(&fd, rustix::io::FdFlags::CLOEXEC)?;
received_fd = Some(fd);
}
}
}
if received.bytes != payload.len()
|| received
.flags
.intersects(net::ReturnFlags::TRUNC | net::ReturnFlags::CTRUNC)
|| u64::from_le_bytes(payload) != tag
{
return Err(invalid(TRANSFER));
}
received_fd.ok_or_else(|| invalid(TRANSFER))
}
}